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"
76 /* Temp hacks for tracepoint encoding migration. */
77 static char *target_buf
;
78 static long target_buf_size
;
80 /* Per-program-space data key. */
81 static const struct program_space_data
*remote_pspace_data
;
83 /* The variable registered as the control variable used by the
84 remote exec-file commands. While the remote exec-file setting is
85 per-program-space, the set/show machinery uses this as the
86 location of the remote exec-file value. */
87 static char *remote_exec_file_var
;
89 /* The size to align memory write packets, when practical. The protocol
90 does not guarantee any alignment, and gdb will generate short
91 writes and unaligned writes, but even as a best-effort attempt this
92 can improve bulk transfers. For instance, if a write is misaligned
93 relative to the target's data bus, the stub may need to make an extra
94 round trip fetching data from the target. This doesn't make a
95 huge difference, but it's easy to do, so we try to be helpful.
97 The alignment chosen is arbitrary; usually data bus width is
98 important here, not the possibly larger cache line size. */
99 enum { REMOTE_ALIGN_WRITES
= 16 };
101 /* Prototypes for local functions. */
102 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
103 static int getpkt_or_notif_sane (char **buf
, long *sizeof_buf
,
104 int forever
, int *is_notif
);
106 static void remote_files_info (struct target_ops
*ignore
);
108 static void remote_prepare_to_store (struct target_ops
*self
,
109 struct regcache
*regcache
);
111 static void remote_open_1 (const char *, int, struct target_ops
*,
114 static void remote_close (struct target_ops
*self
);
118 static int remote_vkill (int pid
, struct remote_state
*rs
);
120 static void remote_kill_k (void);
122 static void remote_mourn (struct target_ops
*ops
);
124 static void extended_remote_restart (void);
126 static void remote_send (char **buf
, long *sizeof_buf_p
);
128 static int readchar (int timeout
);
130 static void remote_serial_write (const char *str
, int len
);
132 static void remote_kill (struct target_ops
*ops
);
134 static int remote_can_async_p (struct target_ops
*);
136 static int remote_is_async_p (struct target_ops
*);
138 static void remote_async (struct target_ops
*ops
, int enable
);
140 static void remote_thread_events (struct target_ops
*ops
, int enable
);
142 static void interrupt_query (void);
144 static void set_general_thread (ptid_t ptid
);
145 static void set_continue_thread (ptid_t ptid
);
147 static void get_offsets (void);
149 static void skip_frame (void);
151 static long read_frame (char **buf_p
, long *sizeof_buf
);
153 static int hexnumlen (ULONGEST num
);
155 static void init_remote_ops (void);
157 static void init_extended_remote_ops (void);
159 static void remote_stop (struct target_ops
*self
, ptid_t
);
161 static int stubhex (int ch
);
163 static int hexnumstr (char *, ULONGEST
);
165 static int hexnumnstr (char *, ULONGEST
, int);
167 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
169 static void print_packet (const char *);
171 static void compare_sections_command (char *, int);
173 static void packet_command (char *, int);
175 static int stub_unpack_int (char *buff
, int fieldlength
);
177 static ptid_t
remote_current_thread (ptid_t oldptid
);
179 static int putpkt_binary (const char *buf
, int cnt
);
181 static void check_binary_download (CORE_ADDR addr
);
183 struct packet_config
;
185 static void show_packet_config_cmd (struct packet_config
*config
);
187 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
189 struct cmd_list_element
*c
,
192 static char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
193 static ptid_t
read_ptid (char *buf
, char **obuf
);
195 static void remote_set_permissions (struct target_ops
*self
);
197 static int remote_get_trace_status (struct target_ops
*self
,
198 struct trace_status
*ts
);
200 static int remote_upload_tracepoints (struct target_ops
*self
,
201 struct uploaded_tp
**utpp
);
203 static int remote_upload_trace_state_variables (struct target_ops
*self
,
204 struct uploaded_tsv
**utsvp
);
206 static void remote_query_supported (void);
208 static void remote_check_symbols (void);
210 void _initialize_remote (void);
213 static void stop_reply_xfree (struct stop_reply
*);
214 static void remote_parse_stop_reply (char *, struct stop_reply
*);
215 static void push_stop_reply (struct stop_reply
*);
216 static void discard_pending_stop_replies_in_queue (struct remote_state
*);
217 static int peek_stop_reply (ptid_t ptid
);
219 struct threads_listing_context
;
220 static void remove_new_fork_children (struct threads_listing_context
*);
222 static void remote_async_inferior_event_handler (gdb_client_data
);
224 static void remote_terminal_ours (struct target_ops
*self
);
226 static int remote_read_description_p (struct target_ops
*target
);
228 static void remote_console_output (char *msg
);
230 static int remote_supports_cond_breakpoints (struct target_ops
*self
);
232 static int remote_can_run_breakpoint_commands (struct target_ops
*self
);
234 static void remote_btrace_reset (void);
236 static void remote_btrace_maybe_reopen (void);
238 static int stop_reply_queue_length (void);
240 static void readahead_cache_invalidate (void);
242 static void remote_unpush_and_throw (void);
246 static struct cmd_list_element
*remote_cmdlist
;
248 /* For "set remote" and "show remote". */
250 static struct cmd_list_element
*remote_set_cmdlist
;
251 static struct cmd_list_element
*remote_show_cmdlist
;
253 /* Stub vCont actions support.
255 Each field is a boolean flag indicating whether the stub reports
256 support for the corresponding action. */
258 struct vCont_action_support
273 /* Controls whether GDB is willing to use range stepping. */
275 static int use_range_stepping
= 1;
277 #define OPAQUETHREADBYTES 8
279 /* a 64 bit opaque identifier */
280 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
282 /* About this many threadisds fit in a packet. */
284 #define MAXTHREADLISTRESULTS 32
286 /* The max number of chars in debug output. The rest of chars are
289 #define REMOTE_DEBUG_MAX_CHAR 512
291 /* Data for the vFile:pread readahead cache. */
293 struct readahead_cache
295 /* The file descriptor for the file that is being cached. -1 if the
299 /* The offset into the file that the cache buffer corresponds
303 /* The buffer holding the cache contents. */
305 /* The buffer's size. We try to read as much as fits into a packet
309 /* Cache hit and miss counters. */
314 /* Description of the remote protocol state for the currently
315 connected target. This is per-target state, and independent of the
316 selected architecture. */
320 /* A buffer to use for incoming packets, and its current size. The
321 buffer is grown dynamically for larger incoming packets.
322 Outgoing packets may also be constructed in this buffer.
323 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
324 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
329 /* True if we're going through initial connection setup (finding out
330 about the remote side's threads, relocating symbols, etc.). */
333 /* If we negotiated packet size explicitly (and thus can bypass
334 heuristics for the largest packet size that will not overflow
335 a buffer in the stub), this will be set to that packet size.
336 Otherwise zero, meaning to use the guessed size. */
337 long explicit_packet_size
;
339 /* remote_wait is normally called when the target is running and
340 waits for a stop reply packet. But sometimes we need to call it
341 when the target is already stopped. We can send a "?" packet
342 and have remote_wait read the response. Or, if we already have
343 the response, we can stash it in BUF and tell remote_wait to
344 skip calling getpkt. This flag is set when BUF contains a
345 stop reply packet and the target is not waiting. */
346 int cached_wait_status
;
348 /* True, if in no ack mode. That is, neither GDB nor the stub will
349 expect acks from each other. The connection is assumed to be
353 /* True if we're connected in extended remote mode. */
356 /* True if we resumed the target and we're waiting for the target to
357 stop. In the mean time, we can't start another command/query.
358 The remote server wouldn't be ready to process it, so we'd
359 timeout waiting for a reply that would never come and eventually
360 we'd close the connection. This can happen in asynchronous mode
361 because we allow GDB commands while the target is running. */
362 int waiting_for_stop_reply
;
364 /* The status of the stub support for the various vCont actions. */
365 struct vCont_action_support supports_vCont
;
367 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
368 responded to that. */
371 /* True if we saw a Ctrl-C while reading or writing from/to the
372 remote descriptor. At that point it is not safe to send a remote
373 interrupt packet, so we instead remember we saw the Ctrl-C and
374 process it once we're done with sending/receiving the current
375 packet, which should be shortly. If however that takes too long,
376 and the user presses Ctrl-C again, we offer to disconnect. */
377 int got_ctrlc_during_io
;
379 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
380 remote_open knows that we don't have a file open when the program
382 struct serial
*remote_desc
;
384 /* These are the threads which we last sent to the remote system. The
385 TID member will be -1 for all or -2 for not sent yet. */
386 ptid_t general_thread
;
387 ptid_t continue_thread
;
389 /* This is the traceframe which we last selected on the remote system.
390 It will be -1 if no traceframe is selected. */
391 int remote_traceframe_number
;
393 char *last_pass_packet
;
395 /* The last QProgramSignals packet sent to the target. We bypass
396 sending a new program signals list down to the target if the new
397 packet is exactly the same as the last we sent. IOW, we only let
398 the target know about program signals list changes. */
399 char *last_program_signals_packet
;
401 enum gdb_signal last_sent_signal
;
405 /* The execution direction of the last resume we got. */
406 enum exec_direction_kind last_resume_exec_dir
;
408 char *finished_object
;
409 char *finished_annex
;
410 ULONGEST finished_offset
;
412 /* Should we try the 'ThreadInfo' query packet?
414 This variable (NOT available to the user: auto-detect only!)
415 determines whether GDB will use the new, simpler "ThreadInfo"
416 query or the older, more complex syntax for thread queries.
417 This is an auto-detect variable (set to true at each connect,
418 and set to false when the target fails to recognize it). */
419 int use_threadinfo_query
;
420 int use_threadextra_query
;
422 threadref echo_nextthread
;
423 threadref nextthread
;
424 threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
426 /* The state of remote notification. */
427 struct remote_notif_state
*notif_state
;
429 /* The branch trace configuration. */
430 struct btrace_config btrace_config
;
432 /* The argument to the last "vFile:setfs:" packet we sent, used
433 to avoid sending repeated unnecessary "vFile:setfs:" packets.
434 Initialized to -1 to indicate that no "vFile:setfs:" packet
435 has yet been sent. */
438 /* A readahead cache for vFile:pread. Often, reading a binary
439 involves a sequence of small reads. E.g., when parsing an ELF
440 file. A readahead cache helps mostly the case of remote
441 debugging on a connection with higher latency, due to the
442 request/reply nature of the RSP. We only cache data for a single
443 file descriptor at a time. */
444 struct readahead_cache readahead_cache
;
447 /* Private data that we'll store in (struct thread_info)->private. */
448 struct private_thread_info
454 /* Whether the target stopped for a breakpoint/watchpoint. */
455 enum target_stop_reason stop_reason
;
457 /* This is set to the data address of the access causing the target
458 to stop for a watchpoint. */
459 CORE_ADDR watch_data_address
;
461 /* Fields used by the vCont action coalescing implemented in
462 remote_resume / remote_commit_resume. remote_resume stores each
463 thread's last resume request in these fields, so that a later
464 remote_commit_resume knows which is the proper action for this
465 thread to include in the vCont packet. */
467 /* True if the last target_resume call for this thread was a step
468 request, false if a continue request. */
469 int last_resume_step
;
471 /* The signal specified in the last target_resume call for this
473 enum gdb_signal last_resume_sig
;
475 /* Whether this thread was already vCont-resumed on the remote
481 free_private_thread_info (struct private_thread_info
*info
)
488 /* This data could be associated with a target, but we do not always
489 have access to the current target when we need it, so for now it is
490 static. This will be fine for as long as only one target is in use
492 static struct remote_state
*remote_state
;
494 static struct remote_state
*
495 get_remote_state_raw (void)
500 /* Allocate a new struct remote_state with xmalloc, initialize it, and
503 static struct remote_state
*
504 new_remote_state (void)
506 struct remote_state
*result
= XCNEW (struct remote_state
);
508 /* The default buffer size is unimportant; it will be expanded
509 whenever a larger buffer is needed. */
510 result
->buf_size
= 400;
511 result
->buf
= (char *) xmalloc (result
->buf_size
);
512 result
->remote_traceframe_number
= -1;
513 result
->last_sent_signal
= GDB_SIGNAL_0
;
514 result
->last_resume_exec_dir
= EXEC_FORWARD
;
520 /* Description of the remote protocol for a given architecture. */
524 long offset
; /* Offset into G packet. */
525 long regnum
; /* GDB's internal register number. */
526 LONGEST pnum
; /* Remote protocol register number. */
527 int in_g_packet
; /* Always part of G packet. */
528 /* long size in bytes; == register_size (target_gdbarch (), regnum);
530 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
534 struct remote_arch_state
536 /* Description of the remote protocol registers. */
537 long sizeof_g_packet
;
539 /* Description of the remote protocol registers indexed by REGNUM
540 (making an array gdbarch_num_regs in size). */
541 struct packet_reg
*regs
;
543 /* This is the size (in chars) of the first response to the ``g''
544 packet. It is used as a heuristic when determining the maximum
545 size of memory-read and memory-write packets. A target will
546 typically only reserve a buffer large enough to hold the ``g''
547 packet. The size does not include packet overhead (headers and
549 long actual_register_packet_size
;
551 /* This is the maximum size (in chars) of a non read/write packet.
552 It is also used as a cap on the size of read/write packets. */
553 long remote_packet_size
;
556 /* Utility: generate error from an incoming stub packet. */
558 trace_error (char *buf
)
561 return; /* not an error msg */
564 case '1': /* malformed packet error */
565 if (*++buf
== '0') /* general case: */
566 error (_("remote.c: error in outgoing packet."));
568 error (_("remote.c: error in outgoing packet at field #%ld."),
569 strtol (buf
, NULL
, 16));
571 error (_("Target returns error code '%s'."), buf
);
575 /* Utility: wait for reply from stub, while accepting "O" packets. */
577 remote_get_noisy_reply (char **buf_p
,
580 do /* Loop on reply from remote stub. */
584 QUIT
; /* Allow user to bail out with ^C. */
585 getpkt (buf_p
, sizeof_buf
, 0);
589 else if (startswith (buf
, "qRelocInsn:"))
592 CORE_ADDR from
, to
, org_to
;
594 int adjusted_size
= 0;
597 p
= buf
+ strlen ("qRelocInsn:");
598 pp
= unpack_varlen_hex (p
, &ul
);
600 error (_("invalid qRelocInsn packet: %s"), buf
);
604 unpack_varlen_hex (p
, &ul
);
611 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
614 CATCH (ex
, RETURN_MASK_ALL
)
616 if (ex
.error
== MEMORY_ERROR
)
618 /* Propagate memory errors silently back to the
619 target. The stub may have limited the range of
620 addresses we can write to, for example. */
624 /* Something unexpectedly bad happened. Be verbose
625 so we can tell what, and propagate the error back
626 to the stub, so it doesn't get stuck waiting for
628 exception_fprintf (gdb_stderr
, ex
,
629 _("warning: relocating instruction: "));
637 adjusted_size
= to
- org_to
;
639 xsnprintf (buf
, *sizeof_buf
, "qRelocInsn:%x", adjusted_size
);
643 else if (buf
[0] == 'O' && buf
[1] != 'K')
644 remote_console_output (buf
+ 1); /* 'O' message from stub */
646 return buf
; /* Here's the actual reply. */
651 /* Handle for retreving the remote protocol data from gdbarch. */
652 static struct gdbarch_data
*remote_gdbarch_data_handle
;
654 static struct remote_arch_state
*
655 get_remote_arch_state (void)
657 gdb_assert (target_gdbarch () != NULL
);
658 return ((struct remote_arch_state
*)
659 gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle
));
662 /* Fetch the global remote target state. */
664 static struct remote_state
*
665 get_remote_state (void)
667 /* Make sure that the remote architecture state has been
668 initialized, because doing so might reallocate rs->buf. Any
669 function which calls getpkt also needs to be mindful of changes
670 to rs->buf, but this call limits the number of places which run
672 get_remote_arch_state ();
674 return get_remote_state_raw ();
677 /* Cleanup routine for the remote module's pspace data. */
680 remote_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
682 char *remote_exec_file
= (char *) arg
;
684 xfree (remote_exec_file
);
687 /* Fetch the remote exec-file from the current program space. */
690 get_remote_exec_file (void)
692 char *remote_exec_file
;
695 = (char *) program_space_data (current_program_space
,
697 if (remote_exec_file
== NULL
)
700 return remote_exec_file
;
703 /* Set the remote exec file for PSPACE. */
706 set_pspace_remote_exec_file (struct program_space
*pspace
,
707 char *remote_exec_file
)
709 char *old_file
= (char *) program_space_data (pspace
, remote_pspace_data
);
712 set_program_space_data (pspace
, remote_pspace_data
,
713 xstrdup (remote_exec_file
));
716 /* The "set/show remote exec-file" set command hook. */
719 set_remote_exec_file (char *ignored
, int from_tty
,
720 struct cmd_list_element
*c
)
722 gdb_assert (remote_exec_file_var
!= NULL
);
723 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
726 /* The "set/show remote exec-file" show command hook. */
729 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
730 struct cmd_list_element
*cmd
, const char *value
)
732 fprintf_filtered (file
, "%s\n", remote_exec_file_var
);
736 compare_pnums (const void *lhs_
, const void *rhs_
)
738 const struct packet_reg
* const *lhs
739 = (const struct packet_reg
* const *) lhs_
;
740 const struct packet_reg
* const *rhs
741 = (const struct packet_reg
* const *) rhs_
;
743 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
745 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
752 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
754 int regnum
, num_remote_regs
, offset
;
755 struct packet_reg
**remote_regs
;
757 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
759 struct packet_reg
*r
= ®s
[regnum
];
761 if (register_size (gdbarch
, regnum
) == 0)
762 /* Do not try to fetch zero-sized (placeholder) registers. */
765 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
770 /* Define the g/G packet format as the contents of each register
771 with a remote protocol number, in order of ascending protocol
774 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
775 for (num_remote_regs
= 0, regnum
= 0;
776 regnum
< gdbarch_num_regs (gdbarch
);
778 if (regs
[regnum
].pnum
!= -1)
779 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
781 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
784 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
786 remote_regs
[regnum
]->in_g_packet
= 1;
787 remote_regs
[regnum
]->offset
= offset
;
788 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
794 /* Given the architecture described by GDBARCH, return the remote
795 protocol register's number and the register's offset in the g/G
796 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
797 If the target does not have a mapping for REGNUM, return false,
798 otherwise, return true. */
801 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
802 int *pnum
, int *poffset
)
804 struct packet_reg
*regs
;
805 struct cleanup
*old_chain
;
807 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
809 regs
= XCNEWVEC (struct packet_reg
, gdbarch_num_regs (gdbarch
));
810 old_chain
= make_cleanup (xfree
, regs
);
812 map_regcache_remote_table (gdbarch
, regs
);
814 *pnum
= regs
[regnum
].pnum
;
815 *poffset
= regs
[regnum
].offset
;
817 do_cleanups (old_chain
);
823 init_remote_state (struct gdbarch
*gdbarch
)
825 struct remote_state
*rs
= get_remote_state_raw ();
826 struct remote_arch_state
*rsa
;
828 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
830 /* Use the architecture to build a regnum<->pnum table, which will be
831 1:1 unless a feature set specifies otherwise. */
832 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
833 gdbarch_num_regs (gdbarch
),
836 /* Record the maximum possible size of the g packet - it may turn out
838 rsa
->sizeof_g_packet
= map_regcache_remote_table (gdbarch
, rsa
->regs
);
840 /* Default maximum number of characters in a packet body. Many
841 remote stubs have a hardwired buffer size of 400 bytes
842 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
843 as the maximum packet-size to ensure that the packet and an extra
844 NUL character can always fit in the buffer. This stops GDB
845 trashing stubs that try to squeeze an extra NUL into what is
846 already a full buffer (As of 1999-12-04 that was most stubs). */
847 rsa
->remote_packet_size
= 400 - 1;
849 /* This one is filled in when a ``g'' packet is received. */
850 rsa
->actual_register_packet_size
= 0;
852 /* Should rsa->sizeof_g_packet needs more space than the
853 default, adjust the size accordingly. Remember that each byte is
854 encoded as two characters. 32 is the overhead for the packet
855 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
856 (``$NN:G...#NN'') is a better guess, the below has been padded a
858 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
859 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
861 /* Make sure that the packet buffer is plenty big enough for
862 this architecture. */
863 if (rs
->buf_size
< rsa
->remote_packet_size
)
865 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
866 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
872 /* Return the current allowed size of a remote packet. This is
873 inferred from the current architecture, and should be used to
874 limit the length of outgoing packets. */
876 get_remote_packet_size (void)
878 struct remote_state
*rs
= get_remote_state ();
879 struct remote_arch_state
*rsa
= get_remote_arch_state ();
881 if (rs
->explicit_packet_size
)
882 return rs
->explicit_packet_size
;
884 return rsa
->remote_packet_size
;
887 static struct packet_reg
*
888 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
890 if (regnum
< 0 && regnum
>= gdbarch_num_regs (target_gdbarch ()))
894 struct packet_reg
*r
= &rsa
->regs
[regnum
];
896 gdb_assert (r
->regnum
== regnum
);
901 static struct packet_reg
*
902 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
906 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
908 struct packet_reg
*r
= &rsa
->regs
[i
];
916 static struct target_ops remote_ops
;
918 static struct target_ops extended_remote_ops
;
920 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
921 ``forever'' still use the normal timeout mechanism. This is
922 currently used by the ASYNC code to guarentee that target reads
923 during the initial connect always time-out. Once getpkt has been
924 modified to return a timeout indication and, in turn
925 remote_wait()/wait_for_inferior() have gained a timeout parameter
927 static int wait_forever_enabled_p
= 1;
929 /* Allow the user to specify what sequence to send to the remote
930 when he requests a program interruption: Although ^C is usually
931 what remote systems expect (this is the default, here), it is
932 sometimes preferable to send a break. On other systems such
933 as the Linux kernel, a break followed by g, which is Magic SysRq g
934 is required in order to interrupt the execution. */
935 const char interrupt_sequence_control_c
[] = "Ctrl-C";
936 const char interrupt_sequence_break
[] = "BREAK";
937 const char interrupt_sequence_break_g
[] = "BREAK-g";
938 static const char *const interrupt_sequence_modes
[] =
940 interrupt_sequence_control_c
,
941 interrupt_sequence_break
,
942 interrupt_sequence_break_g
,
945 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
948 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
949 struct cmd_list_element
*c
,
952 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
953 fprintf_filtered (file
,
954 _("Send the ASCII ETX character (Ctrl-c) "
955 "to the remote target to interrupt the "
956 "execution of the program.\n"));
957 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
958 fprintf_filtered (file
,
959 _("send a break signal to the remote target "
960 "to interrupt the execution of the program.\n"));
961 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
962 fprintf_filtered (file
,
963 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
964 "the remote target to interrupt the execution "
965 "of Linux kernel.\n"));
967 internal_error (__FILE__
, __LINE__
,
968 _("Invalid value for interrupt_sequence_mode: %s."),
969 interrupt_sequence_mode
);
972 /* This boolean variable specifies whether interrupt_sequence is sent
973 to the remote target when gdb connects to it.
974 This is mostly needed when you debug the Linux kernel: The Linux kernel
975 expects BREAK g which is Magic SysRq g for connecting gdb. */
976 static int interrupt_on_connect
= 0;
978 /* This variable is used to implement the "set/show remotebreak" commands.
979 Since these commands are now deprecated in favor of "set/show remote
980 interrupt-sequence", it no longer has any effect on the code. */
981 static int remote_break
;
984 set_remotebreak (char *args
, int from_tty
, struct cmd_list_element
*c
)
987 interrupt_sequence_mode
= interrupt_sequence_break
;
989 interrupt_sequence_mode
= interrupt_sequence_control_c
;
993 show_remotebreak (struct ui_file
*file
, int from_tty
,
994 struct cmd_list_element
*c
,
999 /* This variable sets the number of bits in an address that are to be
1000 sent in a memory ("M" or "m") packet. Normally, after stripping
1001 leading zeros, the entire address would be sent. This variable
1002 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1003 initial implementation of remote.c restricted the address sent in
1004 memory packets to ``host::sizeof long'' bytes - (typically 32
1005 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1006 address was never sent. Since fixing this bug may cause a break in
1007 some remote targets this variable is principly provided to
1008 facilitate backward compatibility. */
1010 static unsigned int remote_address_size
;
1012 /* Temporary to track who currently owns the terminal. See
1013 remote_terminal_* for more details. */
1015 static int remote_async_terminal_ours_p
;
1018 /* User configurable variables for the number of characters in a
1019 memory read/write packet. MIN (rsa->remote_packet_size,
1020 rsa->sizeof_g_packet) is the default. Some targets need smaller
1021 values (fifo overruns, et.al.) and some users need larger values
1022 (speed up transfers). The variables ``preferred_*'' (the user
1023 request), ``current_*'' (what was actually set) and ``forced_*''
1024 (Positive - a soft limit, negative - a hard limit). */
1026 struct memory_packet_config
1033 /* The default max memory-write-packet-size. The 16k is historical.
1034 (It came from older GDB's using alloca for buffers and the
1035 knowledge (folklore?) that some hosts don't cope very well with
1036 large alloca calls.) */
1037 #define DEFAULT_MAX_MEMORY_PACKET_SIZE 16384
1039 /* The minimum remote packet size for memory transfers. Ensures we
1040 can write at least one byte. */
1041 #define MIN_MEMORY_PACKET_SIZE 20
1043 /* Compute the current size of a read/write packet. Since this makes
1044 use of ``actual_register_packet_size'' the computation is dynamic. */
1047 get_memory_packet_size (struct memory_packet_config
*config
)
1049 struct remote_state
*rs
= get_remote_state ();
1050 struct remote_arch_state
*rsa
= get_remote_arch_state ();
1053 if (config
->fixed_p
)
1055 if (config
->size
<= 0)
1056 what_they_get
= DEFAULT_MAX_MEMORY_PACKET_SIZE
;
1058 what_they_get
= config
->size
;
1062 what_they_get
= get_remote_packet_size ();
1063 /* Limit the packet to the size specified by the user. */
1064 if (config
->size
> 0
1065 && what_they_get
> config
->size
)
1066 what_they_get
= config
->size
;
1068 /* Limit it to the size of the targets ``g'' response unless we have
1069 permission from the stub to use a larger packet size. */
1070 if (rs
->explicit_packet_size
== 0
1071 && rsa
->actual_register_packet_size
> 0
1072 && what_they_get
> rsa
->actual_register_packet_size
)
1073 what_they_get
= rsa
->actual_register_packet_size
;
1075 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1076 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1078 /* Make sure there is room in the global buffer for this packet
1079 (including its trailing NUL byte). */
1080 if (rs
->buf_size
< what_they_get
+ 1)
1082 rs
->buf_size
= 2 * what_they_get
;
1083 rs
->buf
= (char *) xrealloc (rs
->buf
, 2 * what_they_get
);
1086 return what_they_get
;
1089 /* Update the size of a read/write packet. If they user wants
1090 something really big then do a sanity check. */
1093 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
1095 int fixed_p
= config
->fixed_p
;
1096 long size
= config
->size
;
1099 error (_("Argument required (integer, `fixed' or `limited')."));
1100 else if (strcmp (args
, "hard") == 0
1101 || strcmp (args
, "fixed") == 0)
1103 else if (strcmp (args
, "soft") == 0
1104 || strcmp (args
, "limit") == 0)
1110 size
= strtoul (args
, &end
, 0);
1112 error (_("Invalid %s (bad syntax)."), config
->name
);
1114 /* Instead of explicitly capping the size of a packet to or
1115 disallowing it, the user is allowed to set the size to
1116 something arbitrarily large. */
1119 /* So that the query shows the correct value. */
1121 size
= DEFAULT_MAX_MEMORY_PACKET_SIZE
;
1124 if (fixed_p
&& !config
->fixed_p
)
1126 if (! query (_("The target may not be able to correctly handle a %s\n"
1127 "of %ld bytes. Change the packet size? "),
1128 config
->name
, size
))
1129 error (_("Packet size not changed."));
1131 /* Update the config. */
1132 config
->fixed_p
= fixed_p
;
1133 config
->size
= size
;
1137 show_memory_packet_size (struct memory_packet_config
*config
)
1139 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1140 if (config
->fixed_p
)
1141 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1142 get_memory_packet_size (config
));
1144 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1145 get_memory_packet_size (config
));
1148 static struct memory_packet_config memory_write_packet_config
=
1150 "memory-write-packet-size",
1154 set_memory_write_packet_size (char *args
, int from_tty
)
1156 set_memory_packet_size (args
, &memory_write_packet_config
);
1160 show_memory_write_packet_size (char *args
, int from_tty
)
1162 show_memory_packet_size (&memory_write_packet_config
);
1166 get_memory_write_packet_size (void)
1168 return get_memory_packet_size (&memory_write_packet_config
);
1171 static struct memory_packet_config memory_read_packet_config
=
1173 "memory-read-packet-size",
1177 set_memory_read_packet_size (char *args
, int from_tty
)
1179 set_memory_packet_size (args
, &memory_read_packet_config
);
1183 show_memory_read_packet_size (char *args
, int from_tty
)
1185 show_memory_packet_size (&memory_read_packet_config
);
1189 get_memory_read_packet_size (void)
1191 long size
= get_memory_packet_size (&memory_read_packet_config
);
1193 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1194 extra buffer size argument before the memory read size can be
1195 increased beyond this. */
1196 if (size
> get_remote_packet_size ())
1197 size
= get_remote_packet_size ();
1202 /* Generic configuration support for packets the stub optionally
1203 supports. Allows the user to specify the use of the packet as well
1204 as allowing GDB to auto-detect support in the remote stub. */
1208 PACKET_SUPPORT_UNKNOWN
= 0,
1213 struct packet_config
1218 /* If auto, GDB auto-detects support for this packet or feature,
1219 either through qSupported, or by trying the packet and looking
1220 at the response. If true, GDB assumes the target supports this
1221 packet. If false, the packet is disabled. Configs that don't
1222 have an associated command always have this set to auto. */
1223 enum auto_boolean detect
;
1225 /* Does the target support this packet? */
1226 enum packet_support support
;
1229 /* Analyze a packet's return value and update the packet config
1239 static enum packet_support
packet_config_support (struct packet_config
*config
);
1240 static enum packet_support
packet_support (int packet
);
1243 show_packet_config_cmd (struct packet_config
*config
)
1245 const char *support
= "internal-error";
1247 switch (packet_config_support (config
))
1250 support
= "enabled";
1252 case PACKET_DISABLE
:
1253 support
= "disabled";
1255 case PACKET_SUPPORT_UNKNOWN
:
1256 support
= "unknown";
1259 switch (config
->detect
)
1261 case AUTO_BOOLEAN_AUTO
:
1262 printf_filtered (_("Support for the `%s' packet "
1263 "is auto-detected, currently %s.\n"),
1264 config
->name
, support
);
1266 case AUTO_BOOLEAN_TRUE
:
1267 case AUTO_BOOLEAN_FALSE
:
1268 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1269 config
->name
, support
);
1275 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1276 const char *title
, int legacy
)
1282 config
->name
= name
;
1283 config
->title
= title
;
1284 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1286 show_doc
= xstrprintf ("Show current use of remote "
1287 "protocol `%s' (%s) packet",
1289 /* set/show TITLE-packet {auto,on,off} */
1290 cmd_name
= xstrprintf ("%s-packet", title
);
1291 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1292 &config
->detect
, set_doc
,
1293 show_doc
, NULL
, /* help_doc */
1295 show_remote_protocol_packet_cmd
,
1296 &remote_set_cmdlist
, &remote_show_cmdlist
);
1297 /* The command code copies the documentation strings. */
1300 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1305 legacy_name
= xstrprintf ("%s-packet", name
);
1306 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1307 &remote_set_cmdlist
);
1308 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1309 &remote_show_cmdlist
);
1313 static enum packet_result
1314 packet_check_result (const char *buf
)
1318 /* The stub recognized the packet request. Check that the
1319 operation succeeded. */
1321 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1323 /* "Enn" - definitly an error. */
1324 return PACKET_ERROR
;
1326 /* Always treat "E." as an error. This will be used for
1327 more verbose error messages, such as E.memtypes. */
1328 if (buf
[0] == 'E' && buf
[1] == '.')
1329 return PACKET_ERROR
;
1331 /* The packet may or may not be OK. Just assume it is. */
1335 /* The stub does not support the packet. */
1336 return PACKET_UNKNOWN
;
1339 static enum packet_result
1340 packet_ok (const char *buf
, struct packet_config
*config
)
1342 enum packet_result result
;
1344 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1345 && config
->support
== PACKET_DISABLE
)
1346 internal_error (__FILE__
, __LINE__
,
1347 _("packet_ok: attempt to use a disabled packet"));
1349 result
= packet_check_result (buf
);
1354 /* The stub recognized the packet request. */
1355 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1358 fprintf_unfiltered (gdb_stdlog
,
1359 "Packet %s (%s) is supported\n",
1360 config
->name
, config
->title
);
1361 config
->support
= PACKET_ENABLE
;
1364 case PACKET_UNKNOWN
:
1365 /* The stub does not support the packet. */
1366 if (config
->detect
== AUTO_BOOLEAN_AUTO
1367 && config
->support
== PACKET_ENABLE
)
1369 /* If the stub previously indicated that the packet was
1370 supported then there is a protocol error. */
1371 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1372 config
->name
, config
->title
);
1374 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1376 /* The user set it wrong. */
1377 error (_("Enabled packet %s (%s) not recognized by stub"),
1378 config
->name
, config
->title
);
1382 fprintf_unfiltered (gdb_stdlog
,
1383 "Packet %s (%s) is NOT supported\n",
1384 config
->name
, config
->title
);
1385 config
->support
= PACKET_DISABLE
;
1406 PACKET_vFile_pwrite
,
1408 PACKET_vFile_unlink
,
1409 PACKET_vFile_readlink
,
1412 PACKET_qXfer_features
,
1413 PACKET_qXfer_exec_file
,
1414 PACKET_qXfer_libraries
,
1415 PACKET_qXfer_libraries_svr4
,
1416 PACKET_qXfer_memory_map
,
1417 PACKET_qXfer_spu_read
,
1418 PACKET_qXfer_spu_write
,
1419 PACKET_qXfer_osdata
,
1420 PACKET_qXfer_threads
,
1421 PACKET_qXfer_statictrace_read
,
1422 PACKET_qXfer_traceframe_info
,
1428 PACKET_QPassSignals
,
1429 PACKET_QCatchSyscalls
,
1430 PACKET_QProgramSignals
,
1431 PACKET_QStartupWithShell
,
1433 PACKET_qSearch_memory
,
1436 PACKET_QStartNoAckMode
,
1438 PACKET_qXfer_siginfo_read
,
1439 PACKET_qXfer_siginfo_write
,
1442 /* Support for conditional tracepoints. */
1443 PACKET_ConditionalTracepoints
,
1445 /* Support for target-side breakpoint conditions. */
1446 PACKET_ConditionalBreakpoints
,
1448 /* Support for target-side breakpoint commands. */
1449 PACKET_BreakpointCommands
,
1451 /* Support for fast tracepoints. */
1452 PACKET_FastTracepoints
,
1454 /* Support for static tracepoints. */
1455 PACKET_StaticTracepoints
,
1457 /* Support for installing tracepoints while a trace experiment is
1459 PACKET_InstallInTrace
,
1463 PACKET_TracepointSource
,
1466 PACKET_QDisableRandomization
,
1468 PACKET_QTBuffer_size
,
1472 PACKET_qXfer_btrace
,
1474 /* Support for the QNonStop packet. */
1477 /* Support for the QThreadEvents packet. */
1478 PACKET_QThreadEvents
,
1480 /* Support for multi-process extensions. */
1481 PACKET_multiprocess_feature
,
1483 /* Support for enabling and disabling tracepoints while a trace
1484 experiment is running. */
1485 PACKET_EnableDisableTracepoints_feature
,
1487 /* Support for collecting strings using the tracenz bytecode. */
1488 PACKET_tracenz_feature
,
1490 /* Support for continuing to run a trace experiment while GDB is
1492 PACKET_DisconnectedTracing_feature
,
1494 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
1495 PACKET_augmented_libraries_svr4_read_feature
,
1497 /* Support for the qXfer:btrace-conf:read packet. */
1498 PACKET_qXfer_btrace_conf
,
1500 /* Support for the Qbtrace-conf:bts:size packet. */
1501 PACKET_Qbtrace_conf_bts_size
,
1503 /* Support for swbreak+ feature. */
1504 PACKET_swbreak_feature
,
1506 /* Support for hwbreak+ feature. */
1507 PACKET_hwbreak_feature
,
1509 /* Support for fork events. */
1510 PACKET_fork_event_feature
,
1512 /* Support for vfork events. */
1513 PACKET_vfork_event_feature
,
1515 /* Support for the Qbtrace-conf:pt:size packet. */
1516 PACKET_Qbtrace_conf_pt_size
,
1518 /* Support for exec events. */
1519 PACKET_exec_event_feature
,
1521 /* Support for query supported vCont actions. */
1522 PACKET_vContSupported
,
1524 /* Support remote CTRL-C. */
1527 /* Support TARGET_WAITKIND_NO_RESUMED. */
1533 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
1535 /* Returns the packet's corresponding "set remote foo-packet" command
1536 state. See struct packet_config for more details. */
1538 static enum auto_boolean
1539 packet_set_cmd_state (int packet
)
1541 return remote_protocol_packets
[packet
].detect
;
1544 /* Returns whether a given packet or feature is supported. This takes
1545 into account the state of the corresponding "set remote foo-packet"
1546 command, which may be used to bypass auto-detection. */
1548 static enum packet_support
1549 packet_config_support (struct packet_config
*config
)
1551 switch (config
->detect
)
1553 case AUTO_BOOLEAN_TRUE
:
1554 return PACKET_ENABLE
;
1555 case AUTO_BOOLEAN_FALSE
:
1556 return PACKET_DISABLE
;
1557 case AUTO_BOOLEAN_AUTO
:
1558 return config
->support
;
1560 gdb_assert_not_reached (_("bad switch"));
1564 /* Same as packet_config_support, but takes the packet's enum value as
1567 static enum packet_support
1568 packet_support (int packet
)
1570 struct packet_config
*config
= &remote_protocol_packets
[packet
];
1572 return packet_config_support (config
);
1576 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
1577 struct cmd_list_element
*c
,
1580 struct packet_config
*packet
;
1582 for (packet
= remote_protocol_packets
;
1583 packet
< &remote_protocol_packets
[PACKET_MAX
];
1586 if (&packet
->detect
== c
->var
)
1588 show_packet_config_cmd (packet
);
1592 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
1596 /* Should we try one of the 'Z' requests? */
1600 Z_PACKET_SOFTWARE_BP
,
1601 Z_PACKET_HARDWARE_BP
,
1608 /* For compatibility with older distributions. Provide a ``set remote
1609 Z-packet ...'' command that updates all the Z packet types. */
1611 static enum auto_boolean remote_Z_packet_detect
;
1614 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1615 struct cmd_list_element
*c
)
1619 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1620 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1624 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1625 struct cmd_list_element
*c
,
1630 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1632 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1636 /* Returns true if the multi-process extensions are in effect. */
1639 remote_multi_process_p (struct remote_state
*rs
)
1641 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
1644 /* Returns true if fork events are supported. */
1647 remote_fork_event_p (struct remote_state
*rs
)
1649 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
1652 /* Returns true if vfork events are supported. */
1655 remote_vfork_event_p (struct remote_state
*rs
)
1657 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
1660 /* Returns true if exec events are supported. */
1663 remote_exec_event_p (struct remote_state
*rs
)
1665 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
1668 /* Insert fork catchpoint target routine. If fork events are enabled
1669 then return success, nothing more to do. */
1672 remote_insert_fork_catchpoint (struct target_ops
*ops
, int pid
)
1674 struct remote_state
*rs
= get_remote_state ();
1676 return !remote_fork_event_p (rs
);
1679 /* Remove fork catchpoint target routine. Nothing to do, just
1683 remote_remove_fork_catchpoint (struct target_ops
*ops
, int pid
)
1688 /* Insert vfork catchpoint target routine. If vfork events are enabled
1689 then return success, nothing more to do. */
1692 remote_insert_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1694 struct remote_state
*rs
= get_remote_state ();
1696 return !remote_vfork_event_p (rs
);
1699 /* Remove vfork catchpoint target routine. Nothing to do, just
1703 remote_remove_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1708 /* Insert exec catchpoint target routine. If exec events are
1709 enabled, just return success. */
1712 remote_insert_exec_catchpoint (struct target_ops
*ops
, int pid
)
1714 struct remote_state
*rs
= get_remote_state ();
1716 return !remote_exec_event_p (rs
);
1719 /* Remove exec catchpoint target routine. Nothing to do, just
1723 remote_remove_exec_catchpoint (struct target_ops
*ops
, int pid
)
1729 /* Asynchronous signal handle registered as event loop source for
1730 when we have pending events ready to be passed to the core. */
1732 static struct async_event_handler
*remote_async_inferior_event_token
;
1736 static ptid_t magic_null_ptid
;
1737 static ptid_t not_sent_ptid
;
1738 static ptid_t any_thread_ptid
;
1740 /* Find out if the stub attached to PID (and hence GDB should offer to
1741 detach instead of killing it when bailing out). */
1744 remote_query_attached (int pid
)
1746 struct remote_state
*rs
= get_remote_state ();
1747 size_t size
= get_remote_packet_size ();
1749 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
1752 if (remote_multi_process_p (rs
))
1753 xsnprintf (rs
->buf
, size
, "qAttached:%x", pid
);
1755 xsnprintf (rs
->buf
, size
, "qAttached");
1758 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1760 switch (packet_ok (rs
->buf
,
1761 &remote_protocol_packets
[PACKET_qAttached
]))
1764 if (strcmp (rs
->buf
, "1") == 0)
1768 warning (_("Remote failure reply: %s"), rs
->buf
);
1770 case PACKET_UNKNOWN
:
1777 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1778 has been invented by GDB, instead of reported by the target. Since
1779 we can be connected to a remote system before before knowing about
1780 any inferior, mark the target with execution when we find the first
1781 inferior. If ATTACHED is 1, then we had just attached to this
1782 inferior. If it is 0, then we just created this inferior. If it
1783 is -1, then try querying the remote stub to find out if it had
1784 attached to the inferior or not. If TRY_OPEN_EXEC is true then
1785 attempt to open this inferior's executable as the main executable
1786 if no main executable is open already. */
1788 static struct inferior
*
1789 remote_add_inferior (int fake_pid_p
, int pid
, int attached
,
1792 struct inferior
*inf
;
1794 /* Check whether this process we're learning about is to be
1795 considered attached, or if is to be considered to have been
1796 spawned by the stub. */
1798 attached
= remote_query_attached (pid
);
1800 if (gdbarch_has_global_solist (target_gdbarch ()))
1802 /* If the target shares code across all inferiors, then every
1803 attach adds a new inferior. */
1804 inf
= add_inferior (pid
);
1806 /* ... and every inferior is bound to the same program space.
1807 However, each inferior may still have its own address
1809 inf
->aspace
= maybe_new_address_space ();
1810 inf
->pspace
= current_program_space
;
1814 /* In the traditional debugging scenario, there's a 1-1 match
1815 between program/address spaces. We simply bind the inferior
1816 to the program space's address space. */
1817 inf
= current_inferior ();
1818 inferior_appeared (inf
, pid
);
1821 inf
->attach_flag
= attached
;
1822 inf
->fake_pid_p
= fake_pid_p
;
1824 /* If no main executable is currently open then attempt to
1825 open the file that was executed to create this inferior. */
1826 if (try_open_exec
&& get_exec_file (0) == NULL
)
1827 exec_file_locate_attach (pid
, 0, 1);
1832 static struct private_thread_info
*
1833 get_private_info_thread (struct thread_info
*info
);
1835 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1836 according to RUNNING. */
1839 remote_add_thread (ptid_t ptid
, int running
, int executing
)
1841 struct remote_state
*rs
= get_remote_state ();
1842 struct thread_info
*thread
;
1844 /* GDB historically didn't pull threads in the initial connection
1845 setup. If the remote target doesn't even have a concept of
1846 threads (e.g., a bare-metal target), even if internally we
1847 consider that a single-threaded target, mentioning a new thread
1848 might be confusing to the user. Be silent then, preserving the
1849 age old behavior. */
1850 if (rs
->starting_up
)
1851 thread
= add_thread_silent (ptid
);
1853 thread
= add_thread (ptid
);
1855 get_private_info_thread (thread
)->vcont_resumed
= executing
;
1856 set_executing (ptid
, executing
);
1857 set_running (ptid
, running
);
1860 /* Come here when we learn about a thread id from the remote target.
1861 It may be the first time we hear about such thread, so take the
1862 opportunity to add it to GDB's thread list. In case this is the
1863 first time we're noticing its corresponding inferior, add it to
1864 GDB's inferior list as well. EXECUTING indicates whether the
1865 thread is (internally) executing or stopped. */
1868 remote_notice_new_inferior (ptid_t currthread
, int executing
)
1870 /* In non-stop mode, we assume new found threads are (externally)
1871 running until proven otherwise with a stop reply. In all-stop,
1872 we can only get here if all threads are stopped. */
1873 int running
= target_is_non_stop_p () ? 1 : 0;
1875 /* If this is a new thread, add it to GDB's thread list.
1876 If we leave it up to WFI to do this, bad things will happen. */
1878 if (in_thread_list (currthread
) && is_exited (currthread
))
1880 /* We're seeing an event on a thread id we knew had exited.
1881 This has to be a new thread reusing the old id. Add it. */
1882 remote_add_thread (currthread
, running
, executing
);
1886 if (!in_thread_list (currthread
))
1888 struct inferior
*inf
= NULL
;
1889 int pid
= ptid_get_pid (currthread
);
1891 if (ptid_is_pid (inferior_ptid
)
1892 && pid
== ptid_get_pid (inferior_ptid
))
1894 /* inferior_ptid has no thread member yet. This can happen
1895 with the vAttach -> remote_wait,"TAAthread:" path if the
1896 stub doesn't support qC. This is the first stop reported
1897 after an attach, so this is the main thread. Update the
1898 ptid in the thread list. */
1899 if (in_thread_list (pid_to_ptid (pid
)))
1900 thread_change_ptid (inferior_ptid
, currthread
);
1903 remote_add_thread (currthread
, running
, executing
);
1904 inferior_ptid
= currthread
;
1909 if (ptid_equal (magic_null_ptid
, inferior_ptid
))
1911 /* inferior_ptid is not set yet. This can happen with the
1912 vRun -> remote_wait,"TAAthread:" path if the stub
1913 doesn't support qC. This is the first stop reported
1914 after an attach, so this is the main thread. Update the
1915 ptid in the thread list. */
1916 thread_change_ptid (inferior_ptid
, currthread
);
1920 /* When connecting to a target remote, or to a target
1921 extended-remote which already was debugging an inferior, we
1922 may not know about it yet. Add it before adding its child
1923 thread, so notifications are emitted in a sensible order. */
1924 if (!in_inferior_list (ptid_get_pid (currthread
)))
1926 struct remote_state
*rs
= get_remote_state ();
1927 int fake_pid_p
= !remote_multi_process_p (rs
);
1929 inf
= remote_add_inferior (fake_pid_p
,
1930 ptid_get_pid (currthread
), -1, 1);
1933 /* This is really a new thread. Add it. */
1934 remote_add_thread (currthread
, running
, executing
);
1936 /* If we found a new inferior, let the common code do whatever
1937 it needs to with it (e.g., read shared libraries, insert
1938 breakpoints), unless we're just setting up an all-stop
1942 struct remote_state
*rs
= get_remote_state ();
1944 if (!rs
->starting_up
)
1945 notice_new_inferior (currthread
, executing
, 0);
1950 /* Return THREAD's private thread data, creating it if necessary. */
1952 static struct private_thread_info
*
1953 get_private_info_thread (struct thread_info
*thread
)
1955 gdb_assert (thread
!= NULL
);
1957 if (thread
->priv
== NULL
)
1959 struct private_thread_info
*priv
= XNEW (struct private_thread_info
);
1961 thread
->private_dtor
= free_private_thread_info
;
1962 thread
->priv
= priv
;
1968 priv
->last_resume_step
= 0;
1969 priv
->last_resume_sig
= GDB_SIGNAL_0
;
1970 priv
->vcont_resumed
= 0;
1973 return thread
->priv
;
1976 /* Return PTID's private thread data, creating it if necessary. */
1978 static struct private_thread_info
*
1979 get_private_info_ptid (ptid_t ptid
)
1981 struct thread_info
*info
= find_thread_ptid (ptid
);
1983 return get_private_info_thread (info
);
1986 /* Call this function as a result of
1987 1) A halt indication (T packet) containing a thread id
1988 2) A direct query of currthread
1989 3) Successful execution of set thread */
1992 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
1994 rs
->general_thread
= currthread
;
1997 /* If 'QPassSignals' is supported, tell the remote stub what signals
1998 it can simply pass through to the inferior without reporting. */
2001 remote_pass_signals (struct target_ops
*self
,
2002 int numsigs
, unsigned char *pass_signals
)
2004 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2006 char *pass_packet
, *p
;
2008 struct remote_state
*rs
= get_remote_state ();
2010 gdb_assert (numsigs
< 256);
2011 for (i
= 0; i
< numsigs
; i
++)
2013 if (pass_signals
[i
])
2016 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2017 strcpy (pass_packet
, "QPassSignals:");
2018 p
= pass_packet
+ strlen (pass_packet
);
2019 for (i
= 0; i
< numsigs
; i
++)
2021 if (pass_signals
[i
])
2024 *p
++ = tohex (i
>> 4);
2025 *p
++ = tohex (i
& 15);
2034 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2036 putpkt (pass_packet
);
2037 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2038 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2039 if (rs
->last_pass_packet
)
2040 xfree (rs
->last_pass_packet
);
2041 rs
->last_pass_packet
= pass_packet
;
2044 xfree (pass_packet
);
2048 /* If 'QCatchSyscalls' is supported, tell the remote stub
2049 to report syscalls to GDB. */
2052 remote_set_syscall_catchpoint (struct target_ops
*self
,
2053 int pid
, int needed
, int any_count
,
2054 int table_size
, int *table
)
2057 enum packet_result result
;
2060 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2062 /* Not supported. */
2066 if (needed
&& !any_count
)
2070 /* Count how many syscalls are to be caught (table[sysno] != 0). */
2071 for (i
= 0; i
< table_size
; i
++)
2080 fprintf_unfiltered (gdb_stdlog
,
2081 "remote_set_syscall_catchpoint "
2082 "pid %d needed %d any_count %d n_sysno %d\n",
2083 pid
, needed
, any_count
, n_sysno
);
2088 /* Prepare a packet with the sysno list, assuming max 8+1
2089 characters for a sysno. If the resulting packet size is too
2090 big, fallback on the non-selective packet. */
2091 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2093 catch_packet
= (char *) xmalloc (maxpktsz
);
2094 strcpy (catch_packet
, "QCatchSyscalls:1");
2103 /* Add in catch_packet each syscall to be caught (table[i] != 0). */
2104 for (i
= 0; i
< table_size
; i
++)
2107 p
+= xsnprintf (p
, catch_packet
+ maxpktsz
- p
, ";%x", i
);
2110 if (strlen (catch_packet
) > get_remote_packet_size ())
2112 /* catch_packet too big. Fallback to less efficient
2113 non selective mode, with GDB doing the filtering. */
2114 catch_packet
[sizeof ("QCatchSyscalls:1") - 1] = 0;
2118 catch_packet
= xstrdup ("QCatchSyscalls:0");
2121 struct cleanup
*old_chain
= make_cleanup (xfree
, catch_packet
);
2122 struct remote_state
*rs
= get_remote_state ();
2124 putpkt (catch_packet
);
2125 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2126 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2127 do_cleanups (old_chain
);
2128 if (result
== PACKET_OK
)
2135 /* If 'QProgramSignals' is supported, tell the remote stub what
2136 signals it should pass through to the inferior when detaching. */
2139 remote_program_signals (struct target_ops
*self
,
2140 int numsigs
, unsigned char *signals
)
2142 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2146 struct remote_state
*rs
= get_remote_state ();
2148 gdb_assert (numsigs
< 256);
2149 for (i
= 0; i
< numsigs
; i
++)
2154 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2155 strcpy (packet
, "QProgramSignals:");
2156 p
= packet
+ strlen (packet
);
2157 for (i
= 0; i
< numsigs
; i
++)
2159 if (signal_pass_state (i
))
2162 *p
++ = tohex (i
>> 4);
2163 *p
++ = tohex (i
& 15);
2172 if (!rs
->last_program_signals_packet
2173 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2176 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2177 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2178 xfree (rs
->last_program_signals_packet
);
2179 rs
->last_program_signals_packet
= packet
;
2186 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2187 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2188 thread. If GEN is set, set the general thread, if not, then set
2189 the step/continue thread. */
2191 set_thread (ptid_t ptid
, int gen
)
2193 struct remote_state
*rs
= get_remote_state ();
2194 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2195 char *buf
= rs
->buf
;
2196 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
2198 if (ptid_equal (state
, ptid
))
2202 *buf
++ = gen
? 'g' : 'c';
2203 if (ptid_equal (ptid
, magic_null_ptid
))
2204 xsnprintf (buf
, endbuf
- buf
, "0");
2205 else if (ptid_equal (ptid
, any_thread_ptid
))
2206 xsnprintf (buf
, endbuf
- buf
, "0");
2207 else if (ptid_equal (ptid
, minus_one_ptid
))
2208 xsnprintf (buf
, endbuf
- buf
, "-1");
2210 write_ptid (buf
, endbuf
, ptid
);
2212 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2214 rs
->general_thread
= ptid
;
2216 rs
->continue_thread
= ptid
;
2220 set_general_thread (ptid_t ptid
)
2222 set_thread (ptid
, 1);
2226 set_continue_thread (ptid_t ptid
)
2228 set_thread (ptid
, 0);
2231 /* Change the remote current process. Which thread within the process
2232 ends up selected isn't important, as long as it is the same process
2233 as what INFERIOR_PTID points to.
2235 This comes from that fact that there is no explicit notion of
2236 "selected process" in the protocol. The selected process for
2237 general operations is the process the selected general thread
2241 set_general_process (void)
2243 struct remote_state
*rs
= get_remote_state ();
2245 /* If the remote can't handle multiple processes, don't bother. */
2246 if (!remote_multi_process_p (rs
))
2249 /* We only need to change the remote current thread if it's pointing
2250 at some other process. */
2251 if (ptid_get_pid (rs
->general_thread
) != ptid_get_pid (inferior_ptid
))
2252 set_general_thread (inferior_ptid
);
2256 /* Return nonzero if this is the main thread that we made up ourselves
2257 to model non-threaded targets as single-threaded. */
2260 remote_thread_always_alive (struct target_ops
*ops
, ptid_t ptid
)
2262 if (ptid_equal (ptid
, magic_null_ptid
))
2263 /* The main thread is always alive. */
2266 if (ptid_get_pid (ptid
) != 0 && ptid_get_lwp (ptid
) == 0)
2267 /* The main thread is always alive. This can happen after a
2268 vAttach, if the remote side doesn't support
2275 /* Return nonzero if the thread PTID is still alive on the remote
2279 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2281 struct remote_state
*rs
= get_remote_state ();
2284 /* Check if this is a thread that we made up ourselves to model
2285 non-threaded targets as single-threaded. */
2286 if (remote_thread_always_alive (ops
, ptid
))
2290 endp
= rs
->buf
+ get_remote_packet_size ();
2293 write_ptid (p
, endp
, ptid
);
2296 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2297 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2300 /* Return a pointer to a thread name if we know it and NULL otherwise.
2301 The thread_info object owns the memory for the name. */
2304 remote_thread_name (struct target_ops
*ops
, struct thread_info
*info
)
2306 if (info
->priv
!= NULL
)
2307 return info
->priv
->name
;
2312 /* About these extended threadlist and threadinfo packets. They are
2313 variable length packets but, the fields within them are often fixed
2314 length. They are redundent enough to send over UDP as is the
2315 remote protocol in general. There is a matching unit test module
2318 /* WARNING: This threadref data structure comes from the remote O.S.,
2319 libstub protocol encoding, and remote.c. It is not particularly
2322 /* Right now, the internal structure is int. We want it to be bigger.
2323 Plan to fix this. */
2325 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2327 /* gdb_ext_thread_info is an internal GDB data structure which is
2328 equivalent to the reply of the remote threadinfo packet. */
2330 struct gdb_ext_thread_info
2332 threadref threadid
; /* External form of thread reference. */
2333 int active
; /* Has state interesting to GDB?
2335 char display
[256]; /* Brief state display, name,
2336 blocked/suspended. */
2337 char shortname
[32]; /* To be used to name threads. */
2338 char more_display
[256]; /* Long info, statistics, queue depth,
2342 /* The volume of remote transfers can be limited by submitting
2343 a mask containing bits specifying the desired information.
2344 Use a union of these values as the 'selection' parameter to
2345 get_thread_info. FIXME: Make these TAG names more thread specific. */
2347 #define TAG_THREADID 1
2348 #define TAG_EXISTS 2
2349 #define TAG_DISPLAY 4
2350 #define TAG_THREADNAME 8
2351 #define TAG_MOREDISPLAY 16
2353 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2355 static char *unpack_nibble (char *buf
, int *val
);
2357 static char *unpack_byte (char *buf
, int *value
);
2359 static char *pack_int (char *buf
, int value
);
2361 static char *unpack_int (char *buf
, int *value
);
2363 static char *unpack_string (char *src
, char *dest
, int length
);
2365 static char *pack_threadid (char *pkt
, threadref
*id
);
2367 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2369 void int_to_threadref (threadref
*id
, int value
);
2371 static int threadref_to_int (threadref
*ref
);
2373 static void copy_threadref (threadref
*dest
, threadref
*src
);
2375 static int threadmatch (threadref
*dest
, threadref
*src
);
2377 static char *pack_threadinfo_request (char *pkt
, int mode
,
2380 static int remote_unpack_thread_info_response (char *pkt
,
2381 threadref
*expectedref
,
2382 struct gdb_ext_thread_info
2386 static int remote_get_threadinfo (threadref
*threadid
,
2387 int fieldset
, /*TAG mask */
2388 struct gdb_ext_thread_info
*info
);
2390 static char *pack_threadlist_request (char *pkt
, int startflag
,
2392 threadref
*nextthread
);
2394 static int parse_threadlist_response (char *pkt
,
2396 threadref
*original_echo
,
2397 threadref
*resultlist
,
2400 static int remote_get_threadlist (int startflag
,
2401 threadref
*nextthread
,
2405 threadref
*threadlist
);
2407 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
2409 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
2410 void *context
, int looplimit
);
2412 static int remote_newthread_step (threadref
*ref
, void *context
);
2415 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2416 buffer we're allowed to write to. Returns
2417 BUF+CHARACTERS_WRITTEN. */
2420 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2423 struct remote_state
*rs
= get_remote_state ();
2425 if (remote_multi_process_p (rs
))
2427 pid
= ptid_get_pid (ptid
);
2429 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2431 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2433 tid
= ptid_get_lwp (ptid
);
2435 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2437 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2442 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
2443 passed the last parsed char. Returns null_ptid on error. */
2446 read_ptid (char *buf
, char **obuf
)
2450 ULONGEST pid
= 0, tid
= 0;
2454 /* Multi-process ptid. */
2455 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2457 error (_("invalid remote ptid: %s"), p
);
2460 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2463 return ptid_build (pid
, tid
, 0);
2466 /* No multi-process. Just a tid. */
2467 pp
= unpack_varlen_hex (p
, &tid
);
2469 /* Return null_ptid when no thread id is found. */
2477 /* Since the stub is not sending a process id, then default to
2478 what's in inferior_ptid, unless it's null at this point. If so,
2479 then since there's no way to know the pid of the reported
2480 threads, use the magic number. */
2481 if (ptid_equal (inferior_ptid
, null_ptid
))
2482 pid
= ptid_get_pid (magic_null_ptid
);
2484 pid
= ptid_get_pid (inferior_ptid
);
2488 return ptid_build (pid
, tid
, 0);
2494 if (ch
>= 'a' && ch
<= 'f')
2495 return ch
- 'a' + 10;
2496 if (ch
>= '0' && ch
<= '9')
2498 if (ch
>= 'A' && ch
<= 'F')
2499 return ch
- 'A' + 10;
2504 stub_unpack_int (char *buff
, int fieldlength
)
2511 nibble
= stubhex (*buff
++);
2515 retval
= retval
<< 4;
2521 unpack_nibble (char *buf
, int *val
)
2523 *val
= fromhex (*buf
++);
2528 unpack_byte (char *buf
, int *value
)
2530 *value
= stub_unpack_int (buf
, 2);
2535 pack_int (char *buf
, int value
)
2537 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
2538 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
2539 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
2540 buf
= pack_hex_byte (buf
, (value
& 0xff));
2545 unpack_int (char *buf
, int *value
)
2547 *value
= stub_unpack_int (buf
, 8);
2551 #if 0 /* Currently unused, uncomment when needed. */
2552 static char *pack_string (char *pkt
, char *string
);
2555 pack_string (char *pkt
, char *string
)
2560 len
= strlen (string
);
2562 len
= 200; /* Bigger than most GDB packets, junk??? */
2563 pkt
= pack_hex_byte (pkt
, len
);
2567 if ((ch
== '\0') || (ch
== '#'))
2568 ch
= '*'; /* Protect encapsulation. */
2573 #endif /* 0 (unused) */
2576 unpack_string (char *src
, char *dest
, int length
)
2585 pack_threadid (char *pkt
, threadref
*id
)
2588 unsigned char *altid
;
2590 altid
= (unsigned char *) id
;
2591 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
2593 pkt
= pack_hex_byte (pkt
, *altid
++);
2599 unpack_threadid (char *inbuf
, threadref
*id
)
2602 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2605 altref
= (char *) id
;
2607 while (inbuf
< limit
)
2609 x
= stubhex (*inbuf
++);
2610 y
= stubhex (*inbuf
++);
2611 *altref
++ = (x
<< 4) | y
;
2616 /* Externally, threadrefs are 64 bits but internally, they are still
2617 ints. This is due to a mismatch of specifications. We would like
2618 to use 64bit thread references internally. This is an adapter
2622 int_to_threadref (threadref
*id
, int value
)
2624 unsigned char *scan
;
2626 scan
= (unsigned char *) id
;
2632 *scan
++ = (value
>> 24) & 0xff;
2633 *scan
++ = (value
>> 16) & 0xff;
2634 *scan
++ = (value
>> 8) & 0xff;
2635 *scan
++ = (value
& 0xff);
2639 threadref_to_int (threadref
*ref
)
2642 unsigned char *scan
;
2648 value
= (value
<< 8) | ((*scan
++) & 0xff);
2653 copy_threadref (threadref
*dest
, threadref
*src
)
2656 unsigned char *csrc
, *cdest
;
2658 csrc
= (unsigned char *) src
;
2659 cdest
= (unsigned char *) dest
;
2666 threadmatch (threadref
*dest
, threadref
*src
)
2668 /* Things are broken right now, so just assume we got a match. */
2670 unsigned char *srcp
, *destp
;
2672 srcp
= (char *) src
;
2673 destp
= (char *) dest
;
2677 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2684 threadid:1, # always request threadid
2691 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2694 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2696 *pkt
++ = 'q'; /* Info Query */
2697 *pkt
++ = 'P'; /* process or thread info */
2698 pkt
= pack_int (pkt
, mode
); /* mode */
2699 pkt
= pack_threadid (pkt
, id
); /* threadid */
2700 *pkt
= '\0'; /* terminate */
2704 /* These values tag the fields in a thread info response packet. */
2705 /* Tagging the fields allows us to request specific fields and to
2706 add more fields as time goes by. */
2708 #define TAG_THREADID 1 /* Echo the thread identifier. */
2709 #define TAG_EXISTS 2 /* Is this process defined enough to
2710 fetch registers and its stack? */
2711 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2712 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2713 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2717 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2718 struct gdb_ext_thread_info
*info
)
2720 struct remote_state
*rs
= get_remote_state ();
2724 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2727 /* info->threadid = 0; FIXME: implement zero_threadref. */
2729 info
->display
[0] = '\0';
2730 info
->shortname
[0] = '\0';
2731 info
->more_display
[0] = '\0';
2733 /* Assume the characters indicating the packet type have been
2735 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2736 pkt
= unpack_threadid (pkt
, &ref
);
2739 warning (_("Incomplete response to threadinfo request."));
2740 if (!threadmatch (&ref
, expectedref
))
2741 { /* This is an answer to a different request. */
2742 warning (_("ERROR RMT Thread info mismatch."));
2745 copy_threadref (&info
->threadid
, &ref
);
2747 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2749 /* Packets are terminated with nulls. */
2750 while ((pkt
< limit
) && mask
&& *pkt
)
2752 pkt
= unpack_int (pkt
, &tag
); /* tag */
2753 pkt
= unpack_byte (pkt
, &length
); /* length */
2754 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2756 warning (_("ERROR RMT: threadinfo tag mismatch."));
2760 if (tag
== TAG_THREADID
)
2764 warning (_("ERROR RMT: length of threadid is not 16."));
2768 pkt
= unpack_threadid (pkt
, &ref
);
2769 mask
= mask
& ~TAG_THREADID
;
2772 if (tag
== TAG_EXISTS
)
2774 info
->active
= stub_unpack_int (pkt
, length
);
2776 mask
= mask
& ~(TAG_EXISTS
);
2779 warning (_("ERROR RMT: 'exists' length too long."));
2785 if (tag
== TAG_THREADNAME
)
2787 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2788 mask
= mask
& ~TAG_THREADNAME
;
2791 if (tag
== TAG_DISPLAY
)
2793 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2794 mask
= mask
& ~TAG_DISPLAY
;
2797 if (tag
== TAG_MOREDISPLAY
)
2799 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2800 mask
= mask
& ~TAG_MOREDISPLAY
;
2803 warning (_("ERROR RMT: unknown thread info tag."));
2804 break; /* Not a tag we know about. */
2810 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2811 struct gdb_ext_thread_info
*info
)
2813 struct remote_state
*rs
= get_remote_state ();
2816 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2818 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2820 if (rs
->buf
[0] == '\0')
2823 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2828 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2831 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2832 threadref
*nextthread
)
2834 *pkt
++ = 'q'; /* info query packet */
2835 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2836 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2837 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2838 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2843 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2846 parse_threadlist_response (char *pkt
, int result_limit
,
2847 threadref
*original_echo
, threadref
*resultlist
,
2850 struct remote_state
*rs
= get_remote_state ();
2852 int count
, resultcount
, done
;
2855 /* Assume the 'q' and 'M chars have been stripped. */
2856 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2857 /* done parse past here */
2858 pkt
= unpack_byte (pkt
, &count
); /* count field */
2859 pkt
= unpack_nibble (pkt
, &done
);
2860 /* The first threadid is the argument threadid. */
2861 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2862 while ((count
-- > 0) && (pkt
< limit
))
2864 pkt
= unpack_threadid (pkt
, resultlist
++);
2865 if (resultcount
++ >= result_limit
)
2873 /* Fetch the next batch of threads from the remote. Returns -1 if the
2874 qL packet is not supported, 0 on error and 1 on success. */
2877 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2878 int *done
, int *result_count
, threadref
*threadlist
)
2880 struct remote_state
*rs
= get_remote_state ();
2883 /* Trancate result limit to be smaller than the packet size. */
2884 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
2885 >= get_remote_packet_size ())
2886 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2888 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2890 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2891 if (*rs
->buf
== '\0')
2893 /* Packet not supported. */
2898 parse_threadlist_response (rs
->buf
+ 2, result_limit
,
2899 &rs
->echo_nextthread
, threadlist
, done
);
2901 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
2903 /* FIXME: This is a good reason to drop the packet. */
2904 /* Possably, there is a duplicate response. */
2906 retransmit immediatly - race conditions
2907 retransmit after timeout - yes
2909 wait for packet, then exit
2911 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2912 return 0; /* I choose simply exiting. */
2914 if (*result_count
<= 0)
2918 warning (_("RMT ERROR : failed to get remote thread list."));
2921 return result
; /* break; */
2923 if (*result_count
> result_limit
)
2926 warning (_("RMT ERROR: threadlist response longer than requested."));
2932 /* Fetch the list of remote threads, with the qL packet, and call
2933 STEPFUNCTION for each thread found. Stops iterating and returns 1
2934 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2935 STEPFUNCTION returns false. If the packet is not supported,
2939 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2942 struct remote_state
*rs
= get_remote_state ();
2943 int done
, i
, result_count
;
2951 if (loopcount
++ > looplimit
)
2954 warning (_("Remote fetch threadlist -infinite loop-."));
2957 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
2958 MAXTHREADLISTRESULTS
,
2959 &done
, &result_count
,
2960 rs
->resultthreadlist
);
2963 /* Clear for later iterations. */
2965 /* Setup to resume next batch of thread references, set nextthread. */
2966 if (result_count
>= 1)
2967 copy_threadref (&rs
->nextthread
,
2968 &rs
->resultthreadlist
[result_count
- 1]);
2970 while (result_count
--)
2972 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
2982 /* A thread found on the remote target. */
2984 typedef struct thread_item
2986 /* The thread's PTID. */
2989 /* The thread's extra info. May be NULL. */
2992 /* The thread's name. May be NULL. */
2995 /* The core the thread was running on. -1 if not known. */
2998 DEF_VEC_O(thread_item_t
);
3000 /* Context passed around to the various methods listing remote
3001 threads. As new threads are found, they're added to the ITEMS
3004 struct threads_listing_context
3006 /* The threads found on the remote target. */
3007 VEC (thread_item_t
) *items
;
3010 /* Discard the contents of the constructed thread listing context. */
3013 clear_threads_listing_context (void *p
)
3015 struct threads_listing_context
*context
3016 = (struct threads_listing_context
*) p
;
3018 struct thread_item
*item
;
3020 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3022 xfree (item
->extra
);
3026 VEC_free (thread_item_t
, context
->items
);
3029 /* Remove the thread specified as the related_pid field of WS
3030 from the CONTEXT list. */
3033 threads_listing_context_remove (struct target_waitstatus
*ws
,
3034 struct threads_listing_context
*context
)
3036 struct thread_item
*item
;
3038 ptid_t child_ptid
= ws
->value
.related_pid
;
3040 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3042 if (ptid_equal (item
->ptid
, child_ptid
))
3044 VEC_ordered_remove (thread_item_t
, context
->items
, i
);
3051 remote_newthread_step (threadref
*ref
, void *data
)
3053 struct threads_listing_context
*context
3054 = (struct threads_listing_context
*) data
;
3055 struct thread_item item
;
3056 int pid
= ptid_get_pid (inferior_ptid
);
3058 item
.ptid
= ptid_build (pid
, threadref_to_int (ref
), 0);
3063 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3065 return 1; /* continue iterator */
3068 #define CRAZY_MAX_THREADS 1000
3071 remote_current_thread (ptid_t oldpid
)
3073 struct remote_state
*rs
= get_remote_state ();
3076 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3077 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3082 result
= read_ptid (&rs
->buf
[2], &obuf
);
3083 if (*obuf
!= '\0' && remote_debug
)
3084 fprintf_unfiltered (gdb_stdlog
,
3085 "warning: garbage in qC reply\n");
3093 /* List remote threads using the deprecated qL packet. */
3096 remote_get_threads_with_ql (struct target_ops
*ops
,
3097 struct threads_listing_context
*context
)
3099 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3100 CRAZY_MAX_THREADS
) >= 0)
3106 #if defined(HAVE_LIBEXPAT)
3109 start_thread (struct gdb_xml_parser
*parser
,
3110 const struct gdb_xml_element
*element
,
3111 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
3113 struct threads_listing_context
*data
3114 = (struct threads_listing_context
*) user_data
;
3116 struct thread_item item
;
3118 struct gdb_xml_value
*attr
;
3120 id
= (char *) xml_find_attribute (attributes
, "id")->value
;
3121 item
.ptid
= read_ptid (id
, NULL
);
3123 attr
= xml_find_attribute (attributes
, "core");
3125 item
.core
= *(ULONGEST
*) attr
->value
;
3129 attr
= xml_find_attribute (attributes
, "name");
3130 item
.name
= attr
!= NULL
? xstrdup ((const char *) attr
->value
) : NULL
;
3134 VEC_safe_push (thread_item_t
, data
->items
, &item
);
3138 end_thread (struct gdb_xml_parser
*parser
,
3139 const struct gdb_xml_element
*element
,
3140 void *user_data
, const char *body_text
)
3142 struct threads_listing_context
*data
3143 = (struct threads_listing_context
*) user_data
;
3145 if (body_text
&& *body_text
)
3146 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
3149 const struct gdb_xml_attribute thread_attributes
[] = {
3150 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3151 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3152 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3153 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3156 const struct gdb_xml_element thread_children
[] = {
3157 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3160 const struct gdb_xml_element threads_children
[] = {
3161 { "thread", thread_attributes
, thread_children
,
3162 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3163 start_thread
, end_thread
},
3164 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3167 const struct gdb_xml_element threads_elements
[] = {
3168 { "threads", NULL
, threads_children
,
3169 GDB_XML_EF_NONE
, NULL
, NULL
},
3170 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3175 /* List remote threads using qXfer:threads:read. */
3178 remote_get_threads_with_qxfer (struct target_ops
*ops
,
3179 struct threads_listing_context
*context
)
3181 #if defined(HAVE_LIBEXPAT)
3182 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3184 char *xml
= target_read_stralloc (ops
, TARGET_OBJECT_THREADS
, NULL
);
3185 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
3187 if (xml
!= NULL
&& *xml
!= '\0')
3189 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3190 threads_elements
, xml
, context
);
3193 do_cleanups (back_to
);
3201 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3204 remote_get_threads_with_qthreadinfo (struct target_ops
*ops
,
3205 struct threads_listing_context
*context
)
3207 struct remote_state
*rs
= get_remote_state ();
3209 if (rs
->use_threadinfo_query
)
3213 putpkt ("qfThreadInfo");
3214 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3216 if (bufp
[0] != '\0') /* q packet recognized */
3218 while (*bufp
++ == 'm') /* reply contains one or more TID */
3222 struct thread_item item
;
3224 item
.ptid
= read_ptid (bufp
, &bufp
);
3229 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3231 while (*bufp
++ == ','); /* comma-separated list */
3232 putpkt ("qsThreadInfo");
3233 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3240 /* Packet not recognized. */
3241 rs
->use_threadinfo_query
= 0;
3248 /* Implement the to_update_thread_list function for the remote
3252 remote_update_thread_list (struct target_ops
*ops
)
3254 struct threads_listing_context context
;
3255 struct cleanup
*old_chain
;
3258 context
.items
= NULL
;
3259 old_chain
= make_cleanup (clear_threads_listing_context
, &context
);
3261 /* We have a few different mechanisms to fetch the thread list. Try
3262 them all, starting with the most preferred one first, falling
3263 back to older methods. */
3264 if (remote_get_threads_with_qxfer (ops
, &context
)
3265 || remote_get_threads_with_qthreadinfo (ops
, &context
)
3266 || remote_get_threads_with_ql (ops
, &context
))
3269 struct thread_item
*item
;
3270 struct thread_info
*tp
, *tmp
;
3274 if (VEC_empty (thread_item_t
, context
.items
)
3275 && remote_thread_always_alive (ops
, inferior_ptid
))
3277 /* Some targets don't really support threads, but still
3278 reply an (empty) thread list in response to the thread
3279 listing packets, instead of replying "packet not
3280 supported". Exit early so we don't delete the main
3282 do_cleanups (old_chain
);
3286 /* CONTEXT now holds the current thread list on the remote
3287 target end. Delete GDB-side threads no longer found on the
3289 ALL_THREADS_SAFE (tp
, tmp
)
3292 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3295 if (ptid_equal (item
->ptid
, tp
->ptid
))
3299 if (i
== VEC_length (thread_item_t
, context
.items
))
3302 delete_thread (tp
->ptid
);
3306 /* Remove any unreported fork child threads from CONTEXT so
3307 that we don't interfere with follow fork, which is where
3308 creation of such threads is handled. */
3309 remove_new_fork_children (&context
);
3311 /* And now add threads we don't know about yet to our list. */
3313 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3316 if (!ptid_equal (item
->ptid
, null_ptid
))
3318 struct private_thread_info
*info
;
3319 /* In non-stop mode, we assume new found threads are
3320 executing until proven otherwise with a stop reply.
3321 In all-stop, we can only get here if all threads are
3323 int executing
= target_is_non_stop_p () ? 1 : 0;
3325 remote_notice_new_inferior (item
->ptid
, executing
);
3327 info
= get_private_info_ptid (item
->ptid
);
3328 info
->core
= item
->core
;
3329 info
->extra
= item
->extra
;
3331 info
->name
= item
->name
;
3339 /* If no thread listing method is supported, then query whether
3340 each known thread is alive, one by one, with the T packet.
3341 If the target doesn't support threads at all, then this is a
3342 no-op. See remote_thread_alive. */
3346 do_cleanups (old_chain
);
3350 * Collect a descriptive string about the given thread.
3351 * The target may say anything it wants to about the thread
3352 * (typically info about its blocked / runnable state, name, etc.).
3353 * This string will appear in the info threads display.
3355 * Optional: targets are not required to implement this function.
3359 remote_threads_extra_info (struct target_ops
*self
, struct thread_info
*tp
)
3361 struct remote_state
*rs
= get_remote_state ();
3365 struct gdb_ext_thread_info threadinfo
;
3366 static char display_buf
[100]; /* arbitrary... */
3367 int n
= 0; /* position in display_buf */
3369 if (rs
->remote_desc
== 0) /* paranoia */
3370 internal_error (__FILE__
, __LINE__
,
3371 _("remote_threads_extra_info"));
3373 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
3374 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_lwp (tp
->ptid
) == 0))
3375 /* This is the main thread which was added by GDB. The remote
3376 server doesn't know about it. */
3379 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3381 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
3383 if (info
&& info
->priv
)
3384 return info
->priv
->extra
;
3389 if (rs
->use_threadextra_query
)
3392 char *endb
= rs
->buf
+ get_remote_packet_size ();
3394 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3396 write_ptid (b
, endb
, tp
->ptid
);
3399 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3400 if (rs
->buf
[0] != 0)
3402 n
= std::min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
3403 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
3404 display_buf
[result
] = '\0';
3409 /* If the above query fails, fall back to the old method. */
3410 rs
->use_threadextra_query
= 0;
3411 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3412 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3413 int_to_threadref (&id
, ptid_get_lwp (tp
->ptid
));
3414 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3415 if (threadinfo
.active
)
3417 if (*threadinfo
.shortname
)
3418 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
3419 " Name: %s,", threadinfo
.shortname
);
3420 if (*threadinfo
.display
)
3421 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3422 " State: %s,", threadinfo
.display
);
3423 if (*threadinfo
.more_display
)
3424 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3425 " Priority: %s", threadinfo
.more_display
);
3429 /* For purely cosmetic reasons, clear up trailing commas. */
3430 if (',' == display_buf
[n
-1])
3431 display_buf
[n
-1] = ' ';
3440 remote_static_tracepoint_marker_at (struct target_ops
*self
, CORE_ADDR addr
,
3441 struct static_tracepoint_marker
*marker
)
3443 struct remote_state
*rs
= get_remote_state ();
3446 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3448 p
+= hexnumstr (p
, addr
);
3450 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3454 error (_("Remote failure reply: %s"), p
);
3458 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3465 static VEC(static_tracepoint_marker_p
) *
3466 remote_static_tracepoint_markers_by_strid (struct target_ops
*self
,
3469 struct remote_state
*rs
= get_remote_state ();
3470 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
3471 struct static_tracepoint_marker
*marker
= NULL
;
3472 struct cleanup
*old_chain
;
3475 /* Ask for a first packet of static tracepoint marker
3478 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3481 error (_("Remote failure reply: %s"), p
);
3483 old_chain
= make_cleanup (free_current_marker
, &marker
);
3488 marker
= XCNEW (struct static_tracepoint_marker
);
3492 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3494 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
3496 VEC_safe_push (static_tracepoint_marker_p
,
3502 release_static_tracepoint_marker (marker
);
3503 memset (marker
, 0, sizeof (*marker
));
3506 while (*p
++ == ','); /* comma-separated list */
3507 /* Ask for another packet of static tracepoint definition. */
3509 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3513 do_cleanups (old_chain
);
3518 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3521 remote_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
3523 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
3527 /* Restart the remote side; this is an extended protocol operation. */
3530 extended_remote_restart (void)
3532 struct remote_state
*rs
= get_remote_state ();
3534 /* Send the restart command; for reasons I don't understand the
3535 remote side really expects a number after the "R". */
3536 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
3539 remote_fileio_reset ();
3542 /* Clean up connection to a remote debugger. */
3545 remote_close (struct target_ops
*self
)
3547 struct remote_state
*rs
= get_remote_state ();
3549 if (rs
->remote_desc
== NULL
)
3550 return; /* already closed */
3552 /* Make sure we leave stdin registered in the event loop. */
3553 remote_terminal_ours (self
);
3555 serial_close (rs
->remote_desc
);
3556 rs
->remote_desc
= NULL
;
3558 /* We don't have a connection to the remote stub anymore. Get rid
3559 of all the inferiors and their threads we were controlling.
3560 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3561 will be unable to find the thread corresponding to (pid, 0, 0). */
3562 inferior_ptid
= null_ptid
;
3563 discard_all_inferiors ();
3565 /* We are closing the remote target, so we should discard
3566 everything of this target. */
3567 discard_pending_stop_replies_in_queue (rs
);
3569 if (remote_async_inferior_event_token
)
3570 delete_async_event_handler (&remote_async_inferior_event_token
);
3572 remote_notif_state_xfree (rs
->notif_state
);
3574 trace_reset_local_state ();
3577 /* Query the remote side for the text, data and bss offsets. */
3582 struct remote_state
*rs
= get_remote_state ();
3585 int lose
, num_segments
= 0, do_sections
, do_segments
;
3586 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
3587 struct section_offsets
*offs
;
3588 struct symfile_segment_data
*data
;
3590 if (symfile_objfile
== NULL
)
3593 putpkt ("qOffsets");
3594 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3597 if (buf
[0] == '\000')
3598 return; /* Return silently. Stub doesn't support
3602 warning (_("Remote failure reply: %s"), buf
);
3606 /* Pick up each field in turn. This used to be done with scanf, but
3607 scanf will make trouble if CORE_ADDR size doesn't match
3608 conversion directives correctly. The following code will work
3609 with any size of CORE_ADDR. */
3610 text_addr
= data_addr
= bss_addr
= 0;
3614 if (startswith (ptr
, "Text="))
3617 /* Don't use strtol, could lose on big values. */
3618 while (*ptr
&& *ptr
!= ';')
3619 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3621 if (startswith (ptr
, ";Data="))
3624 while (*ptr
&& *ptr
!= ';')
3625 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3630 if (!lose
&& startswith (ptr
, ";Bss="))
3633 while (*ptr
&& *ptr
!= ';')
3634 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
3636 if (bss_addr
!= data_addr
)
3637 warning (_("Target reported unsupported offsets: %s"), buf
);
3642 else if (startswith (ptr
, "TextSeg="))
3645 /* Don't use strtol, could lose on big values. */
3646 while (*ptr
&& *ptr
!= ';')
3647 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3650 if (startswith (ptr
, ";DataSeg="))
3653 while (*ptr
&& *ptr
!= ';')
3654 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3662 error (_("Malformed response to offset query, %s"), buf
);
3663 else if (*ptr
!= '\0')
3664 warning (_("Target reported unsupported offsets: %s"), buf
);
3666 offs
= ((struct section_offsets
*)
3667 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
3668 memcpy (offs
, symfile_objfile
->section_offsets
,
3669 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
3671 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
3672 do_segments
= (data
!= NULL
);
3673 do_sections
= num_segments
== 0;
3675 if (num_segments
> 0)
3677 segments
[0] = text_addr
;
3678 segments
[1] = data_addr
;
3680 /* If we have two segments, we can still try to relocate everything
3681 by assuming that the .text and .data offsets apply to the whole
3682 text and data segments. Convert the offsets given in the packet
3683 to base addresses for symfile_map_offsets_to_segments. */
3684 else if (data
&& data
->num_segments
== 2)
3686 segments
[0] = data
->segment_bases
[0] + text_addr
;
3687 segments
[1] = data
->segment_bases
[1] + data_addr
;
3690 /* If the object file has only one segment, assume that it is text
3691 rather than data; main programs with no writable data are rare,
3692 but programs with no code are useless. Of course the code might
3693 have ended up in the data segment... to detect that we would need
3694 the permissions here. */
3695 else if (data
&& data
->num_segments
== 1)
3697 segments
[0] = data
->segment_bases
[0] + text_addr
;
3700 /* There's no way to relocate by segment. */
3706 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
3707 offs
, num_segments
, segments
);
3709 if (ret
== 0 && !do_sections
)
3710 error (_("Can not handle qOffsets TextSeg "
3711 "response with this symbol file"));
3718 free_symfile_segment_data (data
);
3722 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
3724 /* This is a temporary kludge to force data and bss to use the
3725 same offsets because that's what nlmconv does now. The real
3726 solution requires changes to the stub and remote.c that I
3727 don't have time to do right now. */
3729 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
3730 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
3733 objfile_relocate (symfile_objfile
, offs
);
3736 /* Send interrupt_sequence to remote target. */
3738 send_interrupt_sequence (void)
3740 struct remote_state
*rs
= get_remote_state ();
3742 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
3743 remote_serial_write ("\x03", 1);
3744 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
3745 serial_send_break (rs
->remote_desc
);
3746 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
3748 serial_send_break (rs
->remote_desc
);
3749 remote_serial_write ("g", 1);
3752 internal_error (__FILE__
, __LINE__
,
3753 _("Invalid value for interrupt_sequence_mode: %s."),
3754 interrupt_sequence_mode
);
3758 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3759 and extract the PTID. Returns NULL_PTID if not found. */
3762 stop_reply_extract_thread (char *stop_reply
)
3764 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
3768 /* Txx r:val ; r:val (...) */
3771 /* Look for "register" named "thread". */
3776 p1
= strchr (p
, ':');
3780 if (strncmp (p
, "thread", p1
- p
) == 0)
3781 return read_ptid (++p1
, &p
);
3783 p1
= strchr (p
, ';');
3795 /* Determine the remote side's current thread. If we have a stop
3796 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3797 "thread" register we can extract the current thread from. If not,
3798 ask the remote which is the current thread with qC. The former
3799 method avoids a roundtrip. */
3802 get_current_thread (char *wait_status
)
3804 ptid_t ptid
= null_ptid
;
3806 /* Note we don't use remote_parse_stop_reply as that makes use of
3807 the target architecture, which we haven't yet fully determined at
3809 if (wait_status
!= NULL
)
3810 ptid
= stop_reply_extract_thread (wait_status
);
3811 if (ptid_equal (ptid
, null_ptid
))
3812 ptid
= remote_current_thread (inferior_ptid
);
3817 /* Query the remote target for which is the current thread/process,
3818 add it to our tables, and update INFERIOR_PTID. The caller is
3819 responsible for setting the state such that the remote end is ready
3820 to return the current thread.
3822 This function is called after handling the '?' or 'vRun' packets,
3823 whose response is a stop reply from which we can also try
3824 extracting the thread. If the target doesn't support the explicit
3825 qC query, we infer the current thread from that stop reply, passed
3826 in in WAIT_STATUS, which may be NULL. */
3829 add_current_inferior_and_thread (char *wait_status
)
3831 struct remote_state
*rs
= get_remote_state ();
3835 inferior_ptid
= null_ptid
;
3837 /* Now, if we have thread information, update inferior_ptid. */
3838 ptid
= get_current_thread (wait_status
);
3840 if (!ptid_equal (ptid
, null_ptid
))
3842 if (!remote_multi_process_p (rs
))
3845 inferior_ptid
= ptid
;
3849 /* Without this, some commands which require an active target
3850 (such as kill) won't work. This variable serves (at least)
3851 double duty as both the pid of the target process (if it has
3852 such), and as a flag indicating that a target is active. */
3853 inferior_ptid
= magic_null_ptid
;
3857 remote_add_inferior (fake_pid_p
, ptid_get_pid (inferior_ptid
), -1, 1);
3859 /* Add the main thread. */
3860 add_thread_silent (inferior_ptid
);
3863 /* Print info about a thread that was found already stopped on
3867 print_one_stopped_thread (struct thread_info
*thread
)
3869 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
3871 switch_to_thread (thread
->ptid
);
3872 stop_pc
= get_frame_pc (get_current_frame ());
3873 set_current_sal_from_frame (get_current_frame ());
3875 thread
->suspend
.waitstatus_pending_p
= 0;
3877 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
3879 enum gdb_signal sig
= ws
->value
.sig
;
3881 if (signal_print_state (sig
))
3882 observer_notify_signal_received (sig
);
3884 observer_notify_normal_stop (NULL
, 1);
3887 /* Process all initial stop replies the remote side sent in response
3888 to the ? packet. These indicate threads that were already stopped
3889 on initial connection. We mark these threads as stopped and print
3890 their current frame before giving the user the prompt. */
3893 process_initial_stop_replies (int from_tty
)
3895 int pending_stop_replies
= stop_reply_queue_length ();
3896 struct inferior
*inf
;
3897 struct thread_info
*thread
;
3898 struct thread_info
*selected
= NULL
;
3899 struct thread_info
*lowest_stopped
= NULL
;
3900 struct thread_info
*first
= NULL
;
3902 /* Consume the initial pending events. */
3903 while (pending_stop_replies
-- > 0)
3905 ptid_t waiton_ptid
= minus_one_ptid
;
3907 struct target_waitstatus ws
;
3908 int ignore_event
= 0;
3909 struct thread_info
*thread
;
3911 memset (&ws
, 0, sizeof (ws
));
3912 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
3914 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
3918 case TARGET_WAITKIND_IGNORE
:
3919 case TARGET_WAITKIND_NO_RESUMED
:
3920 case TARGET_WAITKIND_SIGNALLED
:
3921 case TARGET_WAITKIND_EXITED
:
3922 /* We shouldn't see these, but if we do, just ignore. */
3924 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
3928 case TARGET_WAITKIND_EXECD
:
3929 xfree (ws
.value
.execd_pathname
);
3938 thread
= find_thread_ptid (event_ptid
);
3940 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
3942 enum gdb_signal sig
= ws
.value
.sig
;
3944 /* Stubs traditionally report SIGTRAP as initial signal,
3945 instead of signal 0. Suppress it. */
3946 if (sig
== GDB_SIGNAL_TRAP
)
3948 thread
->suspend
.stop_signal
= sig
;
3952 thread
->suspend
.waitstatus
= ws
;
3954 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
3955 || ws
.value
.sig
!= GDB_SIGNAL_0
)
3956 thread
->suspend
.waitstatus_pending_p
= 1;
3958 set_executing (event_ptid
, 0);
3959 set_running (event_ptid
, 0);
3960 thread
->priv
->vcont_resumed
= 0;
3963 /* "Notice" the new inferiors before anything related to
3964 registers/memory. */
3970 inf
->needs_setup
= 1;
3974 thread
= any_live_thread_of_process (inf
->pid
);
3975 notice_new_inferior (thread
->ptid
,
3976 thread
->state
== THREAD_RUNNING
,
3981 /* If all-stop on top of non-stop, pause all threads. Note this
3982 records the threads' stop pc, so must be done after "noticing"
3986 stop_all_threads ();
3988 /* If all threads of an inferior were already stopped, we
3989 haven't setup the inferior yet. */
3995 if (inf
->needs_setup
)
3997 thread
= any_live_thread_of_process (inf
->pid
);
3998 switch_to_thread_no_regs (thread
);
4004 /* Now go over all threads that are stopped, and print their current
4005 frame. If all-stop, then if there's a signalled thread, pick
4007 ALL_NON_EXITED_THREADS (thread
)
4013 set_running (thread
->ptid
, 0);
4014 else if (thread
->state
!= THREAD_STOPPED
)
4017 if (selected
== NULL
4018 && thread
->suspend
.waitstatus_pending_p
)
4021 if (lowest_stopped
== NULL
4022 || thread
->inf
->num
< lowest_stopped
->inf
->num
4023 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4024 lowest_stopped
= thread
;
4027 print_one_stopped_thread (thread
);
4030 /* In all-stop, we only print the status of one thread, and leave
4031 others with their status pending. */
4036 thread
= lowest_stopped
;
4040 print_one_stopped_thread (thread
);
4043 /* For "info program". */
4044 thread
= inferior_thread ();
4045 if (thread
->state
== THREAD_STOPPED
)
4046 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4049 /* Start the remote connection and sync state. */
4052 remote_start_remote (int from_tty
, struct target_ops
*target
, int extended_p
)
4054 struct remote_state
*rs
= get_remote_state ();
4055 struct packet_config
*noack_config
;
4056 char *wait_status
= NULL
;
4058 /* Signal other parts that we're going through the initial setup,
4059 and so things may not be stable yet. E.g., we don't try to
4060 install tracepoints until we've relocated symbols. Also, a
4061 Ctrl-C before we're connected and synced up can't interrupt the
4062 target. Instead, it offers to drop the (potentially wedged)
4064 rs
->starting_up
= 1;
4068 if (interrupt_on_connect
)
4069 send_interrupt_sequence ();
4071 /* Ack any packet which the remote side has already sent. */
4072 remote_serial_write ("+", 1);
4074 /* The first packet we send to the target is the optional "supported
4075 packets" request. If the target can answer this, it will tell us
4076 which later probes to skip. */
4077 remote_query_supported ();
4079 /* If the stub wants to get a QAllow, compose one and send it. */
4080 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4081 remote_set_permissions (target
);
4083 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4084 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4085 as a reply to known packet. For packet "vFile:setfs:" it is an
4086 invalid reply and GDB would return error in
4087 remote_hostio_set_filesystem, making remote files access impossible.
4088 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4089 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4091 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4093 putpkt (v_mustreplyempty
);
4094 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4095 if (strcmp (rs
->buf
, "OK") == 0)
4096 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4097 else if (strcmp (rs
->buf
, "") != 0)
4098 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4102 /* Next, we possibly activate noack mode.
4104 If the QStartNoAckMode packet configuration is set to AUTO,
4105 enable noack mode if the stub reported a wish for it with
4108 If set to TRUE, then enable noack mode even if the stub didn't
4109 report it in qSupported. If the stub doesn't reply OK, the
4110 session ends with an error.
4112 If FALSE, then don't activate noack mode, regardless of what the
4113 stub claimed should be the default with qSupported. */
4115 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4116 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4118 putpkt ("QStartNoAckMode");
4119 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4120 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4126 /* Tell the remote that we are using the extended protocol. */
4128 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4131 /* Let the target know which signals it is allowed to pass down to
4133 update_signals_program_target ();
4135 /* Next, if the target can specify a description, read it. We do
4136 this before anything involving memory or registers. */
4137 target_find_description ();
4139 /* Next, now that we know something about the target, update the
4140 address spaces in the program spaces. */
4141 update_address_spaces ();
4143 /* On OSs where the list of libraries is global to all
4144 processes, we fetch them early. */
4145 if (gdbarch_has_global_solist (target_gdbarch ()))
4146 solib_add (NULL
, from_tty
, auto_solib_add
);
4148 if (target_is_non_stop_p ())
4150 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4151 error (_("Non-stop mode requested, but remote "
4152 "does not support non-stop"));
4154 putpkt ("QNonStop:1");
4155 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4157 if (strcmp (rs
->buf
, "OK") != 0)
4158 error (_("Remote refused setting non-stop mode with: %s"), rs
->buf
);
4160 /* Find about threads and processes the stub is already
4161 controlling. We default to adding them in the running state.
4162 The '?' query below will then tell us about which threads are
4164 remote_update_thread_list (target
);
4166 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4168 /* Don't assume that the stub can operate in all-stop mode.
4169 Request it explicitly. */
4170 putpkt ("QNonStop:0");
4171 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4173 if (strcmp (rs
->buf
, "OK") != 0)
4174 error (_("Remote refused setting all-stop mode with: %s"), rs
->buf
);
4177 /* Upload TSVs regardless of whether the target is running or not. The
4178 remote stub, such as GDBserver, may have some predefined or builtin
4179 TSVs, even if the target is not running. */
4180 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4182 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4184 remote_upload_trace_state_variables (target
, &uploaded_tsvs
);
4185 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4188 /* Check whether the target is running now. */
4190 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4192 if (!target_is_non_stop_p ())
4194 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4197 error (_("The target is not running (try extended-remote?)"));
4199 /* We're connected, but not running. Drop out before we
4200 call start_remote. */
4201 rs
->starting_up
= 0;
4206 /* Save the reply for later. */
4207 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
4208 strcpy (wait_status
, rs
->buf
);
4211 /* Fetch thread list. */
4212 target_update_thread_list ();
4214 /* Let the stub know that we want it to return the thread. */
4215 set_continue_thread (minus_one_ptid
);
4217 if (thread_count () == 0)
4219 /* Target has no concept of threads at all. GDB treats
4220 non-threaded target as single-threaded; add a main
4222 add_current_inferior_and_thread (wait_status
);
4226 /* We have thread information; select the thread the target
4227 says should be current. If we're reconnecting to a
4228 multi-threaded program, this will ideally be the thread
4229 that last reported an event before GDB disconnected. */
4230 inferior_ptid
= get_current_thread (wait_status
);
4231 if (ptid_equal (inferior_ptid
, null_ptid
))
4233 /* Odd... The target was able to list threads, but not
4234 tell us which thread was current (no "thread"
4235 register in T stop reply?). Just pick the first
4236 thread in the thread list then. */
4239 fprintf_unfiltered (gdb_stdlog
,
4240 "warning: couldn't determine remote "
4241 "current thread; picking first in list.\n");
4243 inferior_ptid
= thread_list
->ptid
;
4247 /* init_wait_for_inferior should be called before get_offsets in order
4248 to manage `inserted' flag in bp loc in a correct state.
4249 breakpoint_init_inferior, called from init_wait_for_inferior, set
4250 `inserted' flag to 0, while before breakpoint_re_set, called from
4251 start_remote, set `inserted' flag to 1. In the initialization of
4252 inferior, breakpoint_init_inferior should be called first, and then
4253 breakpoint_re_set can be called. If this order is broken, state of
4254 `inserted' flag is wrong, and cause some problems on breakpoint
4256 init_wait_for_inferior ();
4258 get_offsets (); /* Get text, data & bss offsets. */
4260 /* If we could not find a description using qXfer, and we know
4261 how to do it some other way, try again. This is not
4262 supported for non-stop; it could be, but it is tricky if
4263 there are no stopped threads when we connect. */
4264 if (remote_read_description_p (target
)
4265 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4267 target_clear_description ();
4268 target_find_description ();
4271 /* Use the previously fetched status. */
4272 gdb_assert (wait_status
!= NULL
);
4273 strcpy (rs
->buf
, wait_status
);
4274 rs
->cached_wait_status
= 1;
4276 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4280 /* Clear WFI global state. Do this before finding about new
4281 threads and inferiors, and setting the current inferior.
4282 Otherwise we would clear the proceed status of the current
4283 inferior when we want its stop_soon state to be preserved
4284 (see notice_new_inferior). */
4285 init_wait_for_inferior ();
4287 /* In non-stop, we will either get an "OK", meaning that there
4288 are no stopped threads at this time; or, a regular stop
4289 reply. In the latter case, there may be more than one thread
4290 stopped --- we pull them all out using the vStopped
4292 if (strcmp (rs
->buf
, "OK") != 0)
4294 struct notif_client
*notif
= ¬if_client_stop
;
4296 /* remote_notif_get_pending_replies acks this one, and gets
4298 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4299 = remote_notif_parse (notif
, rs
->buf
);
4300 remote_notif_get_pending_events (notif
);
4303 if (thread_count () == 0)
4306 error (_("The target is not running (try extended-remote?)"));
4308 /* We're connected, but not running. Drop out before we
4309 call start_remote. */
4310 rs
->starting_up
= 0;
4314 /* In non-stop mode, any cached wait status will be stored in
4315 the stop reply queue. */
4316 gdb_assert (wait_status
== NULL
);
4318 /* Report all signals during attach/startup. */
4319 remote_pass_signals (target
, 0, NULL
);
4321 /* If there are already stopped threads, mark them stopped and
4322 report their stops before giving the prompt to the user. */
4323 process_initial_stop_replies (from_tty
);
4325 if (target_can_async_p ())
4329 /* If we connected to a live target, do some additional setup. */
4330 if (target_has_execution
)
4332 if (symfile_objfile
) /* No use without a symbol-file. */
4333 remote_check_symbols ();
4336 /* Possibly the target has been engaged in a trace run started
4337 previously; find out where things are at. */
4338 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4340 struct uploaded_tp
*uploaded_tps
= NULL
;
4342 if (current_trace_status ()->running
)
4343 printf_filtered (_("Trace is already running on the target.\n"));
4345 remote_upload_tracepoints (target
, &uploaded_tps
);
4347 merge_uploaded_tracepoints (&uploaded_tps
);
4350 /* Possibly the target has been engaged in a btrace record started
4351 previously; find out where things are at. */
4352 remote_btrace_maybe_reopen ();
4354 /* The thread and inferior lists are now synchronized with the
4355 target, our symbols have been relocated, and we're merged the
4356 target's tracepoints with ours. We're done with basic start
4358 rs
->starting_up
= 0;
4360 /* Maybe breakpoints are global and need to be inserted now. */
4361 if (breakpoints_should_be_inserted_now ())
4362 insert_breakpoints ();
4365 /* Open a connection to a remote debugger.
4366 NAME is the filename used for communication. */
4369 remote_open (const char *name
, int from_tty
)
4371 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
4374 /* Open a connection to a remote debugger using the extended
4375 remote gdb protocol. NAME is the filename used for communication. */
4378 extended_remote_open (const char *name
, int from_tty
)
4380 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
4383 /* Reset all packets back to "unknown support". Called when opening a
4384 new connection to a remote target. */
4387 reset_all_packet_configs_support (void)
4391 for (i
= 0; i
< PACKET_MAX
; i
++)
4392 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4395 /* Initialize all packet configs. */
4398 init_all_packet_configs (void)
4402 for (i
= 0; i
< PACKET_MAX
; i
++)
4404 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4405 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4409 /* Symbol look-up. */
4412 remote_check_symbols (void)
4414 struct remote_state
*rs
= get_remote_state ();
4415 char *msg
, *reply
, *tmp
;
4418 struct cleanup
*old_chain
;
4420 /* The remote side has no concept of inferiors that aren't running
4421 yet, it only knows about running processes. If we're connected
4422 but our current inferior is not running, we should not invite the
4423 remote target to request symbol lookups related to its
4424 (unrelated) current process. */
4425 if (!target_has_execution
)
4428 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4431 /* Make sure the remote is pointing at the right process. Note
4432 there's no way to select "no process". */
4433 set_general_process ();
4435 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4436 because we need both at the same time. */
4437 msg
= (char *) xmalloc (get_remote_packet_size ());
4438 old_chain
= make_cleanup (xfree
, msg
);
4439 reply
= (char *) xmalloc (get_remote_packet_size ());
4440 make_cleanup (free_current_contents
, &reply
);
4441 reply_size
= get_remote_packet_size ();
4443 /* Invite target to request symbol lookups. */
4445 putpkt ("qSymbol::");
4446 getpkt (&reply
, &reply_size
, 0);
4447 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4449 while (startswith (reply
, "qSymbol:"))
4451 struct bound_minimal_symbol sym
;
4454 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
4456 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
4457 if (sym
.minsym
== NULL
)
4458 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
4461 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4462 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4464 /* If this is a function address, return the start of code
4465 instead of any data function descriptor. */
4466 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4470 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
4471 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4475 getpkt (&reply
, &reply_size
, 0);
4478 do_cleanups (old_chain
);
4481 static struct serial
*
4482 remote_serial_open (const char *name
)
4484 static int udp_warning
= 0;
4486 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4487 of in ser-tcp.c, because it is the remote protocol assuming that the
4488 serial connection is reliable and not the serial connection promising
4490 if (!udp_warning
&& startswith (name
, "udp:"))
4492 warning (_("The remote protocol may be unreliable over UDP.\n"
4493 "Some events may be lost, rendering further debugging "
4498 return serial_open (name
);
4501 /* Inform the target of our permission settings. The permission flags
4502 work without this, but if the target knows the settings, it can do
4503 a couple things. First, it can add its own check, to catch cases
4504 that somehow manage to get by the permissions checks in target
4505 methods. Second, if the target is wired to disallow particular
4506 settings (for instance, a system in the field that is not set up to
4507 be able to stop at a breakpoint), it can object to any unavailable
4511 remote_set_permissions (struct target_ops
*self
)
4513 struct remote_state
*rs
= get_remote_state ();
4515 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAllow:"
4516 "WriteReg:%x;WriteMem:%x;"
4517 "InsertBreak:%x;InsertTrace:%x;"
4518 "InsertFastTrace:%x;Stop:%x",
4519 may_write_registers
, may_write_memory
,
4520 may_insert_breakpoints
, may_insert_tracepoints
,
4521 may_insert_fast_tracepoints
, may_stop
);
4523 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4525 /* If the target didn't like the packet, warn the user. Do not try
4526 to undo the user's settings, that would just be maddening. */
4527 if (strcmp (rs
->buf
, "OK") != 0)
4528 warning (_("Remote refused setting permissions with: %s"), rs
->buf
);
4531 /* This type describes each known response to the qSupported
4533 struct protocol_feature
4535 /* The name of this protocol feature. */
4538 /* The default for this protocol feature. */
4539 enum packet_support default_support
;
4541 /* The function to call when this feature is reported, or after
4542 qSupported processing if the feature is not supported.
4543 The first argument points to this structure. The second
4544 argument indicates whether the packet requested support be
4545 enabled, disabled, or probed (or the default, if this function
4546 is being called at the end of processing and this feature was
4547 not reported). The third argument may be NULL; if not NULL, it
4548 is a NUL-terminated string taken from the packet following
4549 this feature's name and an equals sign. */
4550 void (*func
) (const struct protocol_feature
*, enum packet_support
,
4553 /* The corresponding packet for this feature. Only used if
4554 FUNC is remote_supported_packet. */
4559 remote_supported_packet (const struct protocol_feature
*feature
,
4560 enum packet_support support
,
4561 const char *argument
)
4565 warning (_("Remote qSupported response supplied an unexpected value for"
4566 " \"%s\"."), feature
->name
);
4570 remote_protocol_packets
[feature
->packet
].support
= support
;
4574 remote_packet_size (const struct protocol_feature
*feature
,
4575 enum packet_support support
, const char *value
)
4577 struct remote_state
*rs
= get_remote_state ();
4582 if (support
!= PACKET_ENABLE
)
4585 if (value
== NULL
|| *value
== '\0')
4587 warning (_("Remote target reported \"%s\" without a size."),
4593 packet_size
= strtol (value
, &value_end
, 16);
4594 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
4596 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4597 feature
->name
, value
);
4601 /* Record the new maximum packet size. */
4602 rs
->explicit_packet_size
= packet_size
;
4605 static const struct protocol_feature remote_protocol_features
[] = {
4606 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
4607 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
4608 PACKET_qXfer_auxv
},
4609 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
4610 PACKET_qXfer_exec_file
},
4611 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
4612 PACKET_qXfer_features
},
4613 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
4614 PACKET_qXfer_libraries
},
4615 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
4616 PACKET_qXfer_libraries_svr4
},
4617 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
4618 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
4619 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
4620 PACKET_qXfer_memory_map
},
4621 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
4622 PACKET_qXfer_spu_read
},
4623 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
4624 PACKET_qXfer_spu_write
},
4625 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
4626 PACKET_qXfer_osdata
},
4627 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
4628 PACKET_qXfer_threads
},
4629 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
4630 PACKET_qXfer_traceframe_info
},
4631 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
4632 PACKET_QPassSignals
},
4633 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
4634 PACKET_QCatchSyscalls
},
4635 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
4636 PACKET_QProgramSignals
},
4637 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
4638 PACKET_QStartupWithShell
},
4639 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
4640 PACKET_QStartNoAckMode
},
4641 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
4642 PACKET_multiprocess_feature
},
4643 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
4644 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
4645 PACKET_qXfer_siginfo_read
},
4646 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
4647 PACKET_qXfer_siginfo_write
},
4648 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4649 PACKET_ConditionalTracepoints
},
4650 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
4651 PACKET_ConditionalBreakpoints
},
4652 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
4653 PACKET_BreakpointCommands
},
4654 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4655 PACKET_FastTracepoints
},
4656 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4657 PACKET_StaticTracepoints
},
4658 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
4659 PACKET_InstallInTrace
},
4660 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
4661 PACKET_DisconnectedTracing_feature
},
4662 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
4664 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
4666 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
4667 PACKET_TracepointSource
},
4668 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
4670 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4671 PACKET_EnableDisableTracepoints_feature
},
4672 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
4673 PACKET_qXfer_fdpic
},
4674 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
4676 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
4677 PACKET_QDisableRandomization
},
4678 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
4679 { "QTBuffer:size", PACKET_DISABLE
,
4680 remote_supported_packet
, PACKET_QTBuffer_size
},
4681 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
4682 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
4683 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
4684 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
4685 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
4686 PACKET_qXfer_btrace
},
4687 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
4688 PACKET_qXfer_btrace_conf
},
4689 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
4690 PACKET_Qbtrace_conf_bts_size
},
4691 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
4692 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
4693 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
4694 PACKET_fork_event_feature
},
4695 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
4696 PACKET_vfork_event_feature
},
4697 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
4698 PACKET_exec_event_feature
},
4699 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
4700 PACKET_Qbtrace_conf_pt_size
},
4701 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
4702 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
4703 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
4706 static char *remote_support_xml
;
4708 /* Register string appended to "xmlRegisters=" in qSupported query. */
4711 register_remote_support_xml (const char *xml
)
4713 #if defined(HAVE_LIBEXPAT)
4714 if (remote_support_xml
== NULL
)
4715 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
4718 char *copy
= xstrdup (remote_support_xml
+ 13);
4719 char *p
= strtok (copy
, ",");
4723 if (strcmp (p
, xml
) == 0)
4730 while ((p
= strtok (NULL
, ",")) != NULL
);
4733 remote_support_xml
= reconcat (remote_support_xml
,
4734 remote_support_xml
, ",", xml
,
4741 remote_query_supported_append (char *msg
, const char *append
)
4744 return reconcat (msg
, msg
, ";", append
, (char *) NULL
);
4746 return xstrdup (append
);
4750 remote_query_supported (void)
4752 struct remote_state
*rs
= get_remote_state ();
4755 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
4757 /* The packet support flags are handled differently for this packet
4758 than for most others. We treat an error, a disabled packet, and
4759 an empty response identically: any features which must be reported
4760 to be used will be automatically disabled. An empty buffer
4761 accomplishes this, since that is also the representation for a list
4762 containing no features. */
4765 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
4768 struct cleanup
*old_chain
= make_cleanup (free_current_contents
, &q
);
4770 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
4771 q
= remote_query_supported_append (q
, "multiprocess+");
4773 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4774 q
= remote_query_supported_append (q
, "swbreak+");
4775 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4776 q
= remote_query_supported_append (q
, "hwbreak+");
4778 q
= remote_query_supported_append (q
, "qRelocInsn+");
4780 if (packet_set_cmd_state (PACKET_fork_event_feature
)
4781 != AUTO_BOOLEAN_FALSE
)
4782 q
= remote_query_supported_append (q
, "fork-events+");
4783 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
4784 != AUTO_BOOLEAN_FALSE
)
4785 q
= remote_query_supported_append (q
, "vfork-events+");
4786 if (packet_set_cmd_state (PACKET_exec_event_feature
)
4787 != AUTO_BOOLEAN_FALSE
)
4788 q
= remote_query_supported_append (q
, "exec-events+");
4790 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
4791 q
= remote_query_supported_append (q
, "vContSupported+");
4793 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
4794 q
= remote_query_supported_append (q
, "QThreadEvents+");
4796 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
4797 q
= remote_query_supported_append (q
, "no-resumed+");
4799 /* Keep this one last to work around a gdbserver <= 7.10 bug in
4800 the qSupported:xmlRegisters=i386 handling. */
4801 if (remote_support_xml
!= NULL
)
4802 q
= remote_query_supported_append (q
, remote_support_xml
);
4804 q
= reconcat (q
, "qSupported:", q
, (char *) NULL
);
4807 do_cleanups (old_chain
);
4809 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4811 /* If an error occured, warn, but do not return - just reset the
4812 buffer to empty and go on to disable features. */
4813 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
4816 warning (_("Remote failure reply: %s"), rs
->buf
);
4821 memset (seen
, 0, sizeof (seen
));
4826 enum packet_support is_supported
;
4827 char *p
, *end
, *name_end
, *value
;
4829 /* First separate out this item from the rest of the packet. If
4830 there's another item after this, we overwrite the separator
4831 (terminated strings are much easier to work with). */
4833 end
= strchr (p
, ';');
4836 end
= p
+ strlen (p
);
4846 warning (_("empty item in \"qSupported\" response"));
4851 name_end
= strchr (p
, '=');
4854 /* This is a name=value entry. */
4855 is_supported
= PACKET_ENABLE
;
4856 value
= name_end
+ 1;
4865 is_supported
= PACKET_ENABLE
;
4869 is_supported
= PACKET_DISABLE
;
4873 is_supported
= PACKET_SUPPORT_UNKNOWN
;
4877 warning (_("unrecognized item \"%s\" "
4878 "in \"qSupported\" response"), p
);
4884 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4885 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
4887 const struct protocol_feature
*feature
;
4890 feature
= &remote_protocol_features
[i
];
4891 feature
->func (feature
, is_supported
, value
);
4896 /* If we increased the packet size, make sure to increase the global
4897 buffer size also. We delay this until after parsing the entire
4898 qSupported packet, because this is the same buffer we were
4900 if (rs
->buf_size
< rs
->explicit_packet_size
)
4902 rs
->buf_size
= rs
->explicit_packet_size
;
4903 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
4906 /* Handle the defaults for unmentioned features. */
4907 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4910 const struct protocol_feature
*feature
;
4912 feature
= &remote_protocol_features
[i
];
4913 feature
->func (feature
, feature
->default_support
, NULL
);
4917 /* Serial QUIT handler for the remote serial descriptor.
4919 Defers handling a Ctrl-C until we're done with the current
4920 command/response packet sequence, unless:
4922 - We're setting up the connection. Don't send a remote interrupt
4923 request, as we're not fully synced yet. Quit immediately
4926 - The target has been resumed in the foreground
4927 (target_terminal_is_ours is false) with a synchronous resume
4928 packet, and we're blocked waiting for the stop reply, thus a
4929 Ctrl-C should be immediately sent to the target.
4931 - We get a second Ctrl-C while still within the same serial read or
4932 write. In that case the serial is seemingly wedged --- offer to
4935 - We see a second Ctrl-C without target response, after having
4936 previously interrupted the target. In that case the target/stub
4937 is probably wedged --- offer to quit/disconnect.
4941 remote_serial_quit_handler (void)
4943 struct remote_state
*rs
= get_remote_state ();
4945 if (check_quit_flag ())
4947 /* If we're starting up, we're not fully synced yet. Quit
4949 if (rs
->starting_up
)
4951 else if (rs
->got_ctrlc_during_io
)
4953 if (query (_("The target is not responding to GDB commands.\n"
4954 "Stop debugging it? ")))
4955 remote_unpush_and_throw ();
4957 /* If ^C has already been sent once, offer to disconnect. */
4958 else if (!target_terminal_is_ours () && rs
->ctrlc_pending_p
)
4960 /* All-stop protocol, and blocked waiting for stop reply. Send
4961 an interrupt request. */
4962 else if (!target_terminal_is_ours () && rs
->waiting_for_stop_reply
)
4963 target_interrupt (inferior_ptid
);
4965 rs
->got_ctrlc_during_io
= 1;
4969 /* Remove any of the remote.c targets from target stack. Upper targets depend
4970 on it so remove them first. */
4973 remote_unpush_target (void)
4975 pop_all_targets_at_and_above (process_stratum
);
4979 remote_unpush_and_throw (void)
4981 remote_unpush_target ();
4982 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
4986 remote_open_1 (const char *name
, int from_tty
,
4987 struct target_ops
*target
, int extended_p
)
4989 struct remote_state
*rs
= get_remote_state ();
4992 error (_("To open a remote debug connection, you need to specify what\n"
4993 "serial device is attached to the remote system\n"
4994 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
4996 /* See FIXME above. */
4997 if (!target_async_permitted
)
4998 wait_forever_enabled_p
= 1;
5000 /* If we're connected to a running target, target_preopen will kill it.
5001 Ask this question first, before target_preopen has a chance to kill
5003 if (rs
->remote_desc
!= NULL
&& !have_inferiors ())
5006 && !query (_("Already connected to a remote target. Disconnect? ")))
5007 error (_("Still connected."));
5010 /* Here the possibly existing remote target gets unpushed. */
5011 target_preopen (from_tty
);
5013 /* Make sure we send the passed signals list the next time we resume. */
5014 xfree (rs
->last_pass_packet
);
5015 rs
->last_pass_packet
= NULL
;
5017 /* Make sure we send the program signals list the next time we
5019 xfree (rs
->last_program_signals_packet
);
5020 rs
->last_program_signals_packet
= NULL
;
5022 remote_fileio_reset ();
5023 reopen_exec_file ();
5026 rs
->remote_desc
= remote_serial_open (name
);
5027 if (!rs
->remote_desc
)
5028 perror_with_name (name
);
5030 if (baud_rate
!= -1)
5032 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5034 /* The requested speed could not be set. Error out to
5035 top level after closing remote_desc. Take care to
5036 set remote_desc to NULL to avoid closing remote_desc
5038 serial_close (rs
->remote_desc
);
5039 rs
->remote_desc
= NULL
;
5040 perror_with_name (name
);
5044 serial_setparity (rs
->remote_desc
, serial_parity
);
5045 serial_raw (rs
->remote_desc
);
5047 /* If there is something sitting in the buffer we might take it as a
5048 response to a command, which would be bad. */
5049 serial_flush_input (rs
->remote_desc
);
5053 puts_filtered ("Remote debugging using ");
5054 puts_filtered (name
);
5055 puts_filtered ("\n");
5057 push_target (target
); /* Switch to using remote target now. */
5059 /* Register extra event sources in the event loop. */
5060 remote_async_inferior_event_token
5061 = create_async_event_handler (remote_async_inferior_event_handler
,
5063 rs
->notif_state
= remote_notif_state_allocate ();
5065 /* Reset the target state; these things will be queried either by
5066 remote_query_supported or as they are needed. */
5067 reset_all_packet_configs_support ();
5068 rs
->cached_wait_status
= 0;
5069 rs
->explicit_packet_size
= 0;
5071 rs
->extended
= extended_p
;
5072 rs
->waiting_for_stop_reply
= 0;
5073 rs
->ctrlc_pending_p
= 0;
5074 rs
->got_ctrlc_during_io
= 0;
5076 rs
->general_thread
= not_sent_ptid
;
5077 rs
->continue_thread
= not_sent_ptid
;
5078 rs
->remote_traceframe_number
= -1;
5080 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5082 /* Probe for ability to use "ThreadInfo" query, as required. */
5083 rs
->use_threadinfo_query
= 1;
5084 rs
->use_threadextra_query
= 1;
5086 readahead_cache_invalidate ();
5088 /* Start out by owning the terminal. */
5089 remote_async_terminal_ours_p
= 1;
5091 if (target_async_permitted
)
5093 /* FIXME: cagney/1999-09-23: During the initial connection it is
5094 assumed that the target is already ready and able to respond to
5095 requests. Unfortunately remote_start_remote() eventually calls
5096 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5097 around this. Eventually a mechanism that allows
5098 wait_for_inferior() to expect/get timeouts will be
5100 wait_forever_enabled_p
= 0;
5103 /* First delete any symbols previously loaded from shared libraries. */
5104 no_shared_libraries (NULL
, 0);
5107 init_thread_list ();
5109 /* Start the remote connection. If error() or QUIT, discard this
5110 target (we'd otherwise be in an inconsistent state) and then
5111 propogate the error on up the exception chain. This ensures that
5112 the caller doesn't stumble along blindly assuming that the
5113 function succeeded. The CLI doesn't have this problem but other
5114 UI's, such as MI do.
5116 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5117 this function should return an error indication letting the
5118 caller restore the previous state. Unfortunately the command
5119 ``target remote'' is directly wired to this function making that
5120 impossible. On a positive note, the CLI side of this problem has
5121 been fixed - the function set_cmd_context() makes it possible for
5122 all the ``target ....'' commands to share a common callback
5123 function. See cli-dump.c. */
5128 remote_start_remote (from_tty
, target
, extended_p
);
5130 CATCH (ex
, RETURN_MASK_ALL
)
5132 /* Pop the partially set up target - unless something else did
5133 already before throwing the exception. */
5134 if (rs
->remote_desc
!= NULL
)
5135 remote_unpush_target ();
5136 if (target_async_permitted
)
5137 wait_forever_enabled_p
= 1;
5138 throw_exception (ex
);
5143 remote_btrace_reset ();
5145 if (target_async_permitted
)
5146 wait_forever_enabled_p
= 1;
5149 /* Detach the specified process. */
5152 remote_detach_pid (int pid
)
5154 struct remote_state
*rs
= get_remote_state ();
5156 if (remote_multi_process_p (rs
))
5157 xsnprintf (rs
->buf
, get_remote_packet_size (), "D;%x", pid
);
5159 strcpy (rs
->buf
, "D");
5162 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5164 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5166 else if (rs
->buf
[0] == '\0')
5167 error (_("Remote doesn't know how to detach"));
5169 error (_("Can't detach process."));
5172 /* This detaches a program to which we previously attached, using
5173 inferior_ptid to identify the process. After this is done, GDB
5174 can be used to debug some other program. We better not have left
5175 any breakpoints in the target program or it'll die when it hits
5179 remote_detach_1 (const char *args
, int from_tty
)
5181 int pid
= ptid_get_pid (inferior_ptid
);
5182 struct remote_state
*rs
= get_remote_state ();
5183 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5187 error (_("Argument given to \"detach\" when remotely debugging."));
5189 if (!target_has_execution
)
5190 error (_("No process to detach from."));
5192 target_announce_detach (from_tty
);
5194 /* Tell the remote target to detach. */
5195 remote_detach_pid (pid
);
5197 /* Exit only if this is the only active inferior. */
5198 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5199 puts_filtered (_("Ending remote debugging.\n"));
5201 /* Check to see if we are detaching a fork parent. Note that if we
5202 are detaching a fork child, tp == NULL. */
5203 is_fork_parent
= (tp
!= NULL
5204 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5206 /* If doing detach-on-fork, we don't mourn, because that will delete
5207 breakpoints that should be available for the followed inferior. */
5208 if (!is_fork_parent
)
5209 target_mourn_inferior (inferior_ptid
);
5212 inferior_ptid
= null_ptid
;
5213 detach_inferior (pid
);
5218 remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5220 remote_detach_1 (args
, from_tty
);
5224 extended_remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5226 remote_detach_1 (args
, from_tty
);
5229 /* Target follow-fork function for remote targets. On entry, and
5230 at return, the current inferior is the fork parent.
5232 Note that although this is currently only used for extended-remote,
5233 it is named remote_follow_fork in anticipation of using it for the
5234 remote target as well. */
5237 remote_follow_fork (struct target_ops
*ops
, int follow_child
,
5240 struct remote_state
*rs
= get_remote_state ();
5241 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5243 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5244 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5246 /* When following the parent and detaching the child, we detach
5247 the child here. For the case of following the child and
5248 detaching the parent, the detach is done in the target-
5249 independent follow fork code in infrun.c. We can't use
5250 target_detach when detaching an unfollowed child because
5251 the client side doesn't know anything about the child. */
5252 if (detach_fork
&& !follow_child
)
5254 /* Detach the fork child. */
5258 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5259 child_pid
= ptid_get_pid (child_ptid
);
5261 remote_detach_pid (child_pid
);
5262 detach_inferior (child_pid
);
5268 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5269 in the program space of the new inferior. On entry and at return the
5270 current inferior is the exec'ing inferior. INF is the new exec'd
5271 inferior, which may be the same as the exec'ing inferior unless
5272 follow-exec-mode is "new". */
5275 remote_follow_exec (struct target_ops
*ops
,
5276 struct inferior
*inf
, char *execd_pathname
)
5278 /* We know that this is a target file name, so if it has the "target:"
5279 prefix we strip it off before saving it in the program space. */
5280 if (is_target_filename (execd_pathname
))
5281 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5283 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5286 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5289 remote_disconnect (struct target_ops
*target
, const char *args
, int from_tty
)
5292 error (_("Argument given to \"disconnect\" when remotely debugging."));
5294 /* Make sure we unpush even the extended remote targets. Calling
5295 target_mourn_inferior won't unpush, and remote_mourn won't
5296 unpush if there is more than one inferior left. */
5297 unpush_target (target
);
5298 generic_mourn_inferior ();
5301 puts_filtered ("Ending remote debugging.\n");
5304 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5305 be chatty about it. */
5308 extended_remote_attach (struct target_ops
*target
, const char *args
,
5311 struct remote_state
*rs
= get_remote_state ();
5313 char *wait_status
= NULL
;
5315 pid
= parse_pid_to_attach (args
);
5317 /* Remote PID can be freely equal to getpid, do not check it here the same
5318 way as in other targets. */
5320 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5321 error (_("This target does not support attaching to a process"));
5325 char *exec_file
= get_exec_file (0);
5328 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5329 target_pid_to_str (pid_to_ptid (pid
)));
5331 printf_unfiltered (_("Attaching to %s\n"),
5332 target_pid_to_str (pid_to_ptid (pid
)));
5334 gdb_flush (gdb_stdout
);
5337 xsnprintf (rs
->buf
, get_remote_packet_size (), "vAttach;%x", pid
);
5339 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5341 switch (packet_ok (rs
->buf
,
5342 &remote_protocol_packets
[PACKET_vAttach
]))
5345 if (!target_is_non_stop_p ())
5347 /* Save the reply for later. */
5348 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
5349 strcpy (wait_status
, rs
->buf
);
5351 else if (strcmp (rs
->buf
, "OK") != 0)
5352 error (_("Attaching to %s failed with: %s"),
5353 target_pid_to_str (pid_to_ptid (pid
)),
5356 case PACKET_UNKNOWN
:
5357 error (_("This target does not support attaching to a process"));
5359 error (_("Attaching to %s failed"),
5360 target_pid_to_str (pid_to_ptid (pid
)));
5363 set_current_inferior (remote_add_inferior (0, pid
, 1, 0));
5365 inferior_ptid
= pid_to_ptid (pid
);
5367 if (target_is_non_stop_p ())
5369 struct thread_info
*thread
;
5371 /* Get list of threads. */
5372 remote_update_thread_list (target
);
5374 thread
= first_thread_of_process (pid
);
5376 inferior_ptid
= thread
->ptid
;
5378 inferior_ptid
= pid_to_ptid (pid
);
5380 /* Invalidate our notion of the remote current thread. */
5381 record_currthread (rs
, minus_one_ptid
);
5385 /* Now, if we have thread information, update inferior_ptid. */
5386 inferior_ptid
= remote_current_thread (inferior_ptid
);
5388 /* Add the main thread to the thread list. */
5389 add_thread_silent (inferior_ptid
);
5392 /* Next, if the target can specify a description, read it. We do
5393 this before anything involving memory or registers. */
5394 target_find_description ();
5396 if (!target_is_non_stop_p ())
5398 /* Use the previously fetched status. */
5399 gdb_assert (wait_status
!= NULL
);
5401 if (target_can_async_p ())
5403 struct notif_event
*reply
5404 = remote_notif_parse (¬if_client_stop
, wait_status
);
5406 push_stop_reply ((struct stop_reply
*) reply
);
5412 gdb_assert (wait_status
!= NULL
);
5413 strcpy (rs
->buf
, wait_status
);
5414 rs
->cached_wait_status
= 1;
5418 gdb_assert (wait_status
== NULL
);
5421 /* Implementation of the to_post_attach method. */
5424 extended_remote_post_attach (struct target_ops
*ops
, int pid
)
5426 /* Get text, data & bss offsets. */
5429 /* In certain cases GDB might not have had the chance to start
5430 symbol lookup up until now. This could happen if the debugged
5431 binary is not using shared libraries, the vsyscall page is not
5432 present (on Linux) and the binary itself hadn't changed since the
5433 debugging process was started. */
5434 if (symfile_objfile
!= NULL
)
5435 remote_check_symbols();
5439 /* Check for the availability of vCont. This function should also check
5443 remote_vcont_probe (struct remote_state
*rs
)
5447 strcpy (rs
->buf
, "vCont?");
5449 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5452 /* Make sure that the features we assume are supported. */
5453 if (startswith (buf
, "vCont"))
5456 int support_c
, support_C
;
5458 rs
->supports_vCont
.s
= 0;
5459 rs
->supports_vCont
.S
= 0;
5462 rs
->supports_vCont
.t
= 0;
5463 rs
->supports_vCont
.r
= 0;
5464 while (p
&& *p
== ';')
5467 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5468 rs
->supports_vCont
.s
= 1;
5469 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5470 rs
->supports_vCont
.S
= 1;
5471 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5473 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5475 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5476 rs
->supports_vCont
.t
= 1;
5477 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5478 rs
->supports_vCont
.r
= 1;
5480 p
= strchr (p
, ';');
5483 /* If c, and C are not all supported, we can't use vCont. Clearing
5484 BUF will make packet_ok disable the packet. */
5485 if (!support_c
|| !support_C
)
5489 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
5492 /* Helper function for building "vCont" resumptions. Write a
5493 resumption to P. ENDP points to one-passed-the-end of the buffer
5494 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5495 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5496 resumed thread should be single-stepped and/or signalled. If PTID
5497 equals minus_one_ptid, then all threads are resumed; if PTID
5498 represents a process, then all threads of the process are resumed;
5499 the thread to be stepped and/or signalled is given in the global
5503 append_resumption (char *p
, char *endp
,
5504 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5506 struct remote_state
*rs
= get_remote_state ();
5508 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5509 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5511 /* GDB is willing to range step. */
5512 && use_range_stepping
5513 /* Target supports range stepping. */
5514 && rs
->supports_vCont
.r
5515 /* We don't currently support range stepping multiple
5516 threads with a wildcard (though the protocol allows it,
5517 so stubs shouldn't make an active effort to forbid
5519 && !(remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
5521 struct thread_info
*tp
;
5523 if (ptid_equal (ptid
, minus_one_ptid
))
5525 /* If we don't know about the target thread's tid, then
5526 we're resuming magic_null_ptid (see caller). */
5527 tp
= find_thread_ptid (magic_null_ptid
);
5530 tp
= find_thread_ptid (ptid
);
5531 gdb_assert (tp
!= NULL
);
5533 if (tp
->control
.may_range_step
)
5535 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5537 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
5538 phex_nz (tp
->control
.step_range_start
,
5540 phex_nz (tp
->control
.step_range_end
,
5544 p
+= xsnprintf (p
, endp
- p
, ";s");
5547 p
+= xsnprintf (p
, endp
- p
, ";s");
5548 else if (siggnal
!= GDB_SIGNAL_0
)
5549 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
5551 p
+= xsnprintf (p
, endp
- p
, ";c");
5553 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
5557 /* All (-1) threads of process. */
5558 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
5560 p
+= xsnprintf (p
, endp
- p
, ":");
5561 p
= write_ptid (p
, endp
, nptid
);
5563 else if (!ptid_equal (ptid
, minus_one_ptid
))
5565 p
+= xsnprintf (p
, endp
- p
, ":");
5566 p
= write_ptid (p
, endp
, ptid
);
5572 /* Clear the thread's private info on resume. */
5575 resume_clear_thread_private_info (struct thread_info
*thread
)
5577 if (thread
->priv
!= NULL
)
5579 thread
->priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
5580 thread
->priv
->watch_data_address
= 0;
5584 /* Append a vCont continue-with-signal action for threads that have a
5585 non-zero stop signal. */
5588 append_pending_thread_resumptions (char *p
, char *endp
, ptid_t ptid
)
5590 struct thread_info
*thread
;
5592 ALL_NON_EXITED_THREADS (thread
)
5593 if (ptid_match (thread
->ptid
, ptid
)
5594 && !ptid_equal (inferior_ptid
, thread
->ptid
)
5595 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
5597 p
= append_resumption (p
, endp
, thread
->ptid
,
5598 0, thread
->suspend
.stop_signal
);
5599 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5600 resume_clear_thread_private_info (thread
);
5606 /* Set the target running, using the packets that use Hc
5610 remote_resume_with_hc (struct target_ops
*ops
,
5611 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5613 struct remote_state
*rs
= get_remote_state ();
5614 struct thread_info
*thread
;
5617 rs
->last_sent_signal
= siggnal
;
5618 rs
->last_sent_step
= step
;
5620 /* The c/s/C/S resume packets use Hc, so set the continue
5622 if (ptid_equal (ptid
, minus_one_ptid
))
5623 set_continue_thread (any_thread_ptid
);
5625 set_continue_thread (ptid
);
5627 ALL_NON_EXITED_THREADS (thread
)
5628 resume_clear_thread_private_info (thread
);
5631 if (execution_direction
== EXEC_REVERSE
)
5633 /* We don't pass signals to the target in reverse exec mode. */
5634 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
5635 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5638 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
5639 error (_("Remote reverse-step not supported."));
5640 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
5641 error (_("Remote reverse-continue not supported."));
5643 strcpy (buf
, step
? "bs" : "bc");
5645 else if (siggnal
!= GDB_SIGNAL_0
)
5647 buf
[0] = step
? 'S' : 'C';
5648 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
5649 buf
[2] = tohex (((int) siggnal
) & 0xf);
5653 strcpy (buf
, step
? "s" : "c");
5658 /* Resume the remote inferior by using a "vCont" packet. The thread
5659 to be resumed is PTID; STEP and SIGGNAL indicate whether the
5660 resumed thread should be single-stepped and/or signalled. If PTID
5661 equals minus_one_ptid, then all threads are resumed; the thread to
5662 be stepped and/or signalled is given in the global INFERIOR_PTID.
5663 This function returns non-zero iff it resumes the inferior.
5665 This function issues a strict subset of all possible vCont commands
5669 remote_resume_with_vcont (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5671 struct remote_state
*rs
= get_remote_state ();
5675 /* No reverse execution actions defined for vCont. */
5676 if (execution_direction
== EXEC_REVERSE
)
5679 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
5680 remote_vcont_probe (rs
);
5682 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
5686 endp
= rs
->buf
+ get_remote_packet_size ();
5688 /* If we could generate a wider range of packets, we'd have to worry
5689 about overflowing BUF. Should there be a generic
5690 "multi-part-packet" packet? */
5692 p
+= xsnprintf (p
, endp
- p
, "vCont");
5694 if (ptid_equal (ptid
, magic_null_ptid
))
5696 /* MAGIC_NULL_PTID means that we don't have any active threads,
5697 so we don't have any TID numbers the inferior will
5698 understand. Make sure to only send forms that do not specify
5700 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
5702 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
5704 /* Resume all threads (of all processes, or of a single
5705 process), with preference for INFERIOR_PTID. This assumes
5706 inferior_ptid belongs to the set of all threads we are about
5708 if (step
|| siggnal
!= GDB_SIGNAL_0
)
5710 /* Step inferior_ptid, with or without signal. */
5711 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
5714 /* Also pass down any pending signaled resumption for other
5715 threads not the current. */
5716 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
5718 /* And continue others without a signal. */
5719 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
5723 /* Scheduler locking; resume only PTID. */
5724 append_resumption (p
, endp
, ptid
, step
, siggnal
);
5727 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
5730 if (target_is_non_stop_p ())
5732 /* In non-stop, the stub replies to vCont with "OK". The stop
5733 reply will be reported asynchronously by means of a `%Stop'
5735 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5736 if (strcmp (rs
->buf
, "OK") != 0)
5737 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5743 /* Tell the remote machine to resume. */
5746 remote_resume (struct target_ops
*ops
,
5747 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5749 struct remote_state
*rs
= get_remote_state ();
5751 /* When connected in non-stop mode, the core resumes threads
5752 individually. Resuming remote threads directly in target_resume
5753 would thus result in sending one packet per thread. Instead, to
5754 minimize roundtrip latency, here we just store the resume
5755 request; the actual remote resumption will be done in
5756 target_commit_resume / remote_commit_resume, where we'll be able
5757 to do vCont action coalescing. */
5758 if (target_is_non_stop_p () && execution_direction
!= EXEC_REVERSE
)
5760 struct private_thread_info
*remote_thr
;
5762 if (ptid_equal (minus_one_ptid
, ptid
) || ptid_is_pid (ptid
))
5763 remote_thr
= get_private_info_ptid (inferior_ptid
);
5765 remote_thr
= get_private_info_ptid (ptid
);
5766 remote_thr
->last_resume_step
= step
;
5767 remote_thr
->last_resume_sig
= siggnal
;
5771 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5772 (explained in remote-notif.c:handle_notification) so
5773 remote_notif_process is not called. We need find a place where
5774 it is safe to start a 'vNotif' sequence. It is good to do it
5775 before resuming inferior, because inferior was stopped and no RSP
5776 traffic at that moment. */
5777 if (!target_is_non_stop_p ())
5778 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
5780 rs
->last_resume_exec_dir
= execution_direction
;
5782 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
5783 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
5784 remote_resume_with_hc (ops
, ptid
, step
, siggnal
);
5786 /* We are about to start executing the inferior, let's register it
5787 with the event loop. NOTE: this is the one place where all the
5788 execution commands end up. We could alternatively do this in each
5789 of the execution commands in infcmd.c. */
5790 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5791 into infcmd.c in order to allow inferior function calls to work
5792 NOT asynchronously. */
5793 if (target_can_async_p ())
5796 /* We've just told the target to resume. The remote server will
5797 wait for the inferior to stop, and then send a stop reply. In
5798 the mean time, we can't start another command/query ourselves
5799 because the stub wouldn't be ready to process it. This applies
5800 only to the base all-stop protocol, however. In non-stop (which
5801 only supports vCont), the stub replies with an "OK", and is
5802 immediate able to process further serial input. */
5803 if (!target_is_non_stop_p ())
5804 rs
->waiting_for_stop_reply
= 1;
5807 static void check_pending_events_prevent_wildcard_vcont
5808 (int *may_global_wildcard_vcont
);
5809 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
5811 /* Private per-inferior info for target remote processes. */
5813 struct private_inferior
5815 /* Whether we can send a wildcard vCont for this process. */
5816 int may_wildcard_vcont
;
5819 /* Structure used to track the construction of a vCont packet in the
5820 outgoing packet buffer. This is used to send multiple vCont
5821 packets if we have more actions than would fit a single packet. */
5823 struct vcont_builder
5825 /* Pointer to the first action. P points here if no action has been
5829 /* Where the next action will be appended. */
5832 /* The end of the buffer. Must never write past this. */
5836 /* Prepare the outgoing buffer for a new vCont packet. */
5839 vcont_builder_restart (struct vcont_builder
*builder
)
5841 struct remote_state
*rs
= get_remote_state ();
5843 builder
->p
= rs
->buf
;
5844 builder
->endp
= rs
->buf
+ get_remote_packet_size ();
5845 builder
->p
+= xsnprintf (builder
->p
, builder
->endp
- builder
->p
, "vCont");
5846 builder
->first_action
= builder
->p
;
5849 /* If the vCont packet being built has any action, send it to the
5853 vcont_builder_flush (struct vcont_builder
*builder
)
5855 struct remote_state
*rs
;
5857 if (builder
->p
== builder
->first_action
)
5860 rs
= get_remote_state ();
5862 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5863 if (strcmp (rs
->buf
, "OK") != 0)
5864 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5867 /* The largest action is range-stepping, with its two addresses. This
5868 is more than sufficient. If a new, bigger action is created, it'll
5869 quickly trigger a failed assertion in append_resumption (and we'll
5871 #define MAX_ACTION_SIZE 200
5873 /* Append a new vCont action in the outgoing packet being built. If
5874 the action doesn't fit the packet along with previous actions, push
5875 what we've got so far to the remote end and start over a new vCont
5876 packet (with the new action). */
5879 vcont_builder_push_action (struct vcont_builder
*builder
,
5880 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5882 char buf
[MAX_ACTION_SIZE
+ 1];
5886 endp
= append_resumption (buf
, buf
+ sizeof (buf
),
5887 ptid
, step
, siggnal
);
5889 /* Check whether this new action would fit in the vCont packet along
5890 with previous actions. If not, send what we've got so far and
5891 start a new vCont packet. */
5893 if (rsize
> builder
->endp
- builder
->p
)
5895 vcont_builder_flush (builder
);
5896 vcont_builder_restart (builder
);
5898 /* Should now fit. */
5899 gdb_assert (rsize
<= builder
->endp
- builder
->p
);
5902 memcpy (builder
->p
, buf
, rsize
);
5903 builder
->p
+= rsize
;
5907 /* to_commit_resume implementation. */
5910 remote_commit_resume (struct target_ops
*ops
)
5912 struct remote_state
*rs
= get_remote_state ();
5913 struct inferior
*inf
;
5914 struct thread_info
*tp
;
5915 int any_process_wildcard
;
5916 int may_global_wildcard_vcont
;
5917 struct vcont_builder vcont_builder
;
5919 /* If connected in all-stop mode, we'd send the remote resume
5920 request directly from remote_resume. Likewise if
5921 reverse-debugging, as there are no defined vCont actions for
5922 reverse execution. */
5923 if (!target_is_non_stop_p () || execution_direction
== EXEC_REVERSE
)
5926 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
5927 instead of resuming all threads of each process individually.
5928 However, if any thread of a process must remain halted, we can't
5929 send wildcard resumes and must send one action per thread.
5931 Care must be taken to not resume threads/processes the server
5932 side already told us are stopped, but the core doesn't know about
5933 yet, because the events are still in the vStopped notification
5936 #1 => vCont s:p1.1;c
5938 #3 <= %Stopped T05 p1.1
5943 #8 (infrun handles the stop for p1.1 and continues stepping)
5944 #9 => vCont s:p1.1;c
5946 The last vCont above would resume thread p1.2 by mistake, because
5947 the server has no idea that the event for p1.2 had not been
5950 The server side must similarly ignore resume actions for the
5951 thread that has a pending %Stopped notification (and any other
5952 threads with events pending), until GDB acks the notification
5953 with vStopped. Otherwise, e.g., the following case is
5956 #1 => g (or any other packet)
5958 #3 <= %Stopped T05 p1.2
5959 #4 => vCont s:p1.1;c
5962 Above, the server must not resume thread p1.2. GDB can't know
5963 that p1.2 stopped until it acks the %Stopped notification, and
5964 since from GDB's perspective all threads should be running, it
5967 Finally, special care must also be given to handling fork/vfork
5968 events. A (v)fork event actually tells us that two processes
5969 stopped -- the parent and the child. Until we follow the fork,
5970 we must not resume the child. Therefore, if we have a pending
5971 fork follow, we must not send a global wildcard resume action
5972 (vCont;c). We can still send process-wide wildcards though. */
5974 /* Start by assuming a global wildcard (vCont;c) is possible. */
5975 may_global_wildcard_vcont
= 1;
5977 /* And assume every process is individually wildcard-able too. */
5978 ALL_NON_EXITED_INFERIORS (inf
)
5980 if (inf
->priv
== NULL
)
5981 inf
->priv
= XNEW (struct private_inferior
);
5982 inf
->priv
->may_wildcard_vcont
= 1;
5985 /* Check for any pending events (not reported or processed yet) and
5986 disable process and global wildcard resumes appropriately. */
5987 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
5989 ALL_NON_EXITED_THREADS (tp
)
5991 /* If a thread of a process is not meant to be resumed, then we
5992 can't wildcard that process. */
5995 tp
->inf
->priv
->may_wildcard_vcont
= 0;
5997 /* And if we can't wildcard a process, we can't wildcard
5998 everything either. */
5999 may_global_wildcard_vcont
= 0;
6003 /* If a thread is the parent of an unfollowed fork, then we
6004 can't do a global wildcard, as that would resume the fork
6006 if (is_pending_fork_parent_thread (tp
))
6007 may_global_wildcard_vcont
= 0;
6010 /* Now let's build the vCont packet(s). Actions must be appended
6011 from narrower to wider scopes (thread -> process -> global). If
6012 we end up with too many actions for a single packet vcont_builder
6013 flushes the current vCont packet to the remote side and starts a
6015 vcont_builder_restart (&vcont_builder
);
6017 /* Threads first. */
6018 ALL_NON_EXITED_THREADS (tp
)
6020 struct private_thread_info
*remote_thr
= tp
->priv
;
6022 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6025 gdb_assert (!thread_is_in_step_over_chain (tp
));
6027 if (!remote_thr
->last_resume_step
6028 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6029 && tp
->inf
->priv
->may_wildcard_vcont
)
6031 /* We'll send a wildcard resume instead. */
6032 remote_thr
->vcont_resumed
= 1;
6036 vcont_builder_push_action (&vcont_builder
, tp
->ptid
,
6037 remote_thr
->last_resume_step
,
6038 remote_thr
->last_resume_sig
);
6039 remote_thr
->vcont_resumed
= 1;
6042 /* Now check whether we can send any process-wide wildcard. This is
6043 to avoid sending a global wildcard in the case nothing is
6044 supposed to be resumed. */
6045 any_process_wildcard
= 0;
6047 ALL_NON_EXITED_INFERIORS (inf
)
6049 if (inf
->priv
->may_wildcard_vcont
)
6051 any_process_wildcard
= 1;
6056 if (any_process_wildcard
)
6058 /* If all processes are wildcard-able, then send a single "c"
6059 action, otherwise, send an "all (-1) threads of process"
6060 continue action for each running process, if any. */
6061 if (may_global_wildcard_vcont
)
6063 vcont_builder_push_action (&vcont_builder
, minus_one_ptid
,
6068 ALL_NON_EXITED_INFERIORS (inf
)
6070 if (inf
->priv
->may_wildcard_vcont
)
6072 vcont_builder_push_action (&vcont_builder
,
6073 pid_to_ptid (inf
->pid
),
6080 vcont_builder_flush (&vcont_builder
);
6085 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6086 thread, all threads of a remote process, or all threads of all
6090 remote_stop_ns (ptid_t ptid
)
6092 struct remote_state
*rs
= get_remote_state ();
6094 char *endp
= rs
->buf
+ get_remote_packet_size ();
6096 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6097 remote_vcont_probe (rs
);
6099 if (!rs
->supports_vCont
.t
)
6100 error (_("Remote server does not support stopping threads"));
6102 if (ptid_equal (ptid
, minus_one_ptid
)
6103 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
6104 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6109 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6111 if (ptid_is_pid (ptid
))
6112 /* All (-1) threads of process. */
6113 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
6116 /* Small optimization: if we already have a stop reply for
6117 this thread, no use in telling the stub we want this
6119 if (peek_stop_reply (ptid
))
6125 write_ptid (p
, endp
, nptid
);
6128 /* In non-stop, we get an immediate OK reply. The stop reply will
6129 come in asynchronously by notification. */
6131 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6132 if (strcmp (rs
->buf
, "OK") != 0)
6133 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
6136 /* All-stop version of target_interrupt. Sends a break or a ^C to
6137 interrupt the remote target. It is undefined which thread of which
6138 process reports the interrupt. */
6141 remote_interrupt_as (void)
6143 struct remote_state
*rs
= get_remote_state ();
6145 rs
->ctrlc_pending_p
= 1;
6147 /* If the inferior is stopped already, but the core didn't know
6148 about it yet, just ignore the request. The cached wait status
6149 will be collected in remote_wait. */
6150 if (rs
->cached_wait_status
)
6153 /* Send interrupt_sequence to remote target. */
6154 send_interrupt_sequence ();
6157 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6158 the remote target. It is undefined which thread of which process
6159 reports the interrupt. Throws an error if the packet is not
6160 supported by the server. */
6163 remote_interrupt_ns (void)
6165 struct remote_state
*rs
= get_remote_state ();
6167 char *endp
= rs
->buf
+ get_remote_packet_size ();
6169 xsnprintf (p
, endp
- p
, "vCtrlC");
6171 /* In non-stop, we get an immediate OK reply. The stop reply will
6172 come in asynchronously by notification. */
6174 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6176 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6180 case PACKET_UNKNOWN
:
6181 error (_("No support for interrupting the remote target."));
6183 error (_("Interrupting target failed: %s"), rs
->buf
);
6187 /* Implement the to_stop function for the remote targets. */
6190 remote_stop (struct target_ops
*self
, ptid_t ptid
)
6193 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6195 if (target_is_non_stop_p ())
6196 remote_stop_ns (ptid
);
6199 /* We don't currently have a way to transparently pause the
6200 remote target in all-stop mode. Interrupt it instead. */
6201 remote_interrupt_as ();
6205 /* Implement the to_interrupt function for the remote targets. */
6208 remote_interrupt (struct target_ops
*self
, ptid_t ptid
)
6210 struct remote_state
*rs
= get_remote_state ();
6213 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6215 if (target_is_non_stop_p ())
6216 remote_interrupt_ns ();
6218 remote_interrupt_as ();
6221 /* Implement the to_pass_ctrlc function for the remote targets. */
6224 remote_pass_ctrlc (struct target_ops
*self
)
6226 struct remote_state
*rs
= get_remote_state ();
6229 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6231 /* If we're starting up, we're not fully synced yet. Quit
6233 if (rs
->starting_up
)
6235 /* If ^C has already been sent once, offer to disconnect. */
6236 else if (rs
->ctrlc_pending_p
)
6239 target_interrupt (inferior_ptid
);
6242 /* Ask the user what to do when an interrupt is received. */
6245 interrupt_query (void)
6247 struct remote_state
*rs
= get_remote_state ();
6249 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6251 if (query (_("The target is not responding to interrupt requests.\n"
6252 "Stop debugging it? ")))
6254 remote_unpush_target ();
6255 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6260 if (query (_("Interrupted while waiting for the program.\n"
6261 "Give up waiting? ")))
6266 /* Enable/disable target terminal ownership. Most targets can use
6267 terminal groups to control terminal ownership. Remote targets are
6268 different in that explicit transfer of ownership to/from GDB/target
6272 remote_terminal_inferior (struct target_ops
*self
)
6274 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
6275 idempotent. The event-loop GDB talking to an asynchronous target
6276 with a synchronous command calls this function from both
6277 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
6278 transfer the terminal to the target when it shouldn't this guard
6280 if (!remote_async_terminal_ours_p
)
6282 remote_async_terminal_ours_p
= 0;
6283 /* NOTE: At this point we could also register our selves as the
6284 recipient of all input. Any characters typed could then be
6285 passed on down to the target. */
6289 remote_terminal_ours (struct target_ops
*self
)
6291 /* See FIXME in remote_terminal_inferior. */
6292 if (remote_async_terminal_ours_p
)
6294 remote_async_terminal_ours_p
= 1;
6298 remote_console_output (char *msg
)
6302 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6305 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6309 fputs_unfiltered (tb
, gdb_stdtarg
);
6311 gdb_flush (gdb_stdtarg
);
6314 DEF_VEC_O(cached_reg_t
);
6316 typedef struct stop_reply
6318 struct notif_event base
;
6320 /* The identifier of the thread about this event */
6323 /* The remote state this event is associated with. When the remote
6324 connection, represented by a remote_state object, is closed,
6325 all the associated stop_reply events should be released. */
6326 struct remote_state
*rs
;
6328 struct target_waitstatus ws
;
6330 /* Expedited registers. This makes remote debugging a bit more
6331 efficient for those targets that provide critical registers as
6332 part of their normal status mechanism (as another roundtrip to
6333 fetch them is avoided). */
6334 VEC(cached_reg_t
) *regcache
;
6336 enum target_stop_reason stop_reason
;
6338 CORE_ADDR watch_data_address
;
6343 DECLARE_QUEUE_P (stop_reply_p
);
6344 DEFINE_QUEUE_P (stop_reply_p
);
6345 /* The list of already fetched and acknowledged stop events. This
6346 queue is used for notification Stop, and other notifications
6347 don't need queue for their events, because the notification events
6348 of Stop can't be consumed immediately, so that events should be
6349 queued first, and be consumed by remote_wait_{ns,as} one per
6350 time. Other notifications can consume their events immediately,
6351 so queue is not needed for them. */
6352 static QUEUE (stop_reply_p
) *stop_reply_queue
;
6355 stop_reply_xfree (struct stop_reply
*r
)
6357 notif_event_xfree ((struct notif_event
*) r
);
6360 /* Return the length of the stop reply queue. */
6363 stop_reply_queue_length (void)
6365 return QUEUE_length (stop_reply_p
, stop_reply_queue
);
6369 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
6370 struct notif_event
*event
)
6372 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6376 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
6377 struct notif_event
*event
)
6379 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6382 putpkt (self
->ack_command
);
6384 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6385 /* We got an unknown stop reply. */
6386 error (_("Unknown stop reply"));
6388 push_stop_reply (stop_reply
);
6392 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
6394 /* We can't get pending events in remote_notif_process for
6395 notification stop, and we have to do this in remote_wait_ns
6396 instead. If we fetch all queued events from stub, remote stub
6397 may exit and we have no chance to process them back in
6399 mark_async_event_handler (remote_async_inferior_event_token
);
6404 stop_reply_dtr (struct notif_event
*event
)
6406 struct stop_reply
*r
= (struct stop_reply
*) event
;
6411 VEC_iterate (cached_reg_t
, r
->regcache
, ix
, reg
);
6415 VEC_free (cached_reg_t
, r
->regcache
);
6418 static struct notif_event
*
6419 remote_notif_stop_alloc_reply (void)
6421 /* We cast to a pointer to the "base class". */
6422 struct notif_event
*r
= (struct notif_event
*) XNEW (struct stop_reply
);
6424 r
->dtr
= stop_reply_dtr
;
6429 /* A client of notification Stop. */
6431 struct notif_client notif_client_stop
=
6435 remote_notif_stop_parse
,
6436 remote_notif_stop_ack
,
6437 remote_notif_stop_can_get_pending_events
,
6438 remote_notif_stop_alloc_reply
,
6442 /* A parameter to pass data in and out. */
6444 struct queue_iter_param
6447 struct stop_reply
*output
;
6450 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6451 the pid of the process that owns the threads we want to check, or
6452 -1 if we want to check all threads. */
6455 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6458 if (ws
->kind
== TARGET_WAITKIND_FORKED
6459 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6461 if (event_pid
== -1 || event_pid
== ptid_get_pid (thread_ptid
))
6468 /* Return the thread's pending status used to determine whether the
6469 thread is a fork parent stopped at a fork event. */
6471 static struct target_waitstatus
*
6472 thread_pending_fork_status (struct thread_info
*thread
)
6474 if (thread
->suspend
.waitstatus_pending_p
)
6475 return &thread
->suspend
.waitstatus
;
6477 return &thread
->pending_follow
;
6480 /* Determine if THREAD is a pending fork parent thread. */
6483 is_pending_fork_parent_thread (struct thread_info
*thread
)
6485 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6488 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6491 /* Check whether EVENT is a fork event, and if it is, remove the
6492 fork child from the context list passed in DATA. */
6495 remove_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
6496 QUEUE_ITER (stop_reply_p
) *iter
,
6500 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6501 struct threads_listing_context
*context
6502 = (struct threads_listing_context
*) param
->input
;
6504 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6505 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6506 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6507 threads_listing_context_remove (&event
->ws
, context
);
6512 /* If CONTEXT contains any fork child threads that have not been
6513 reported yet, remove them from the CONTEXT list. If such a
6514 thread exists it is because we are stopped at a fork catchpoint
6515 and have not yet called follow_fork, which will set up the
6516 host-side data structures for the new process. */
6519 remove_new_fork_children (struct threads_listing_context
*context
)
6521 struct thread_info
* thread
;
6523 struct notif_client
*notif
= ¬if_client_stop
;
6524 struct queue_iter_param param
;
6526 /* For any threads stopped at a fork event, remove the corresponding
6527 fork child threads from the CONTEXT list. */
6528 ALL_NON_EXITED_THREADS (thread
)
6530 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6532 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6534 threads_listing_context_remove (ws
, context
);
6538 /* Check for any pending fork events (not reported or processed yet)
6539 in process PID and remove those fork child threads from the
6540 CONTEXT list as well. */
6541 remote_notif_get_pending_events (notif
);
6542 param
.input
= context
;
6543 param
.output
= NULL
;
6544 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6545 remove_child_of_pending_fork
, ¶m
);
6548 /* Check whether EVENT would prevent a global or process wildcard
6552 check_pending_event_prevents_wildcard_vcont_callback
6553 (QUEUE (stop_reply_p
) *q
,
6554 QUEUE_ITER (stop_reply_p
) *iter
,
6558 struct inferior
*inf
;
6559 int *may_global_wildcard_vcont
= (int *) data
;
6561 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6562 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6565 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6566 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6567 *may_global_wildcard_vcont
= 0;
6569 inf
= find_inferior_ptid (event
->ptid
);
6571 /* This may be the first time we heard about this process.
6572 Regardless, we must not do a global wildcard resume, otherwise
6573 we'd resume this process too. */
6574 *may_global_wildcard_vcont
= 0;
6576 inf
->priv
->may_wildcard_vcont
= 0;
6581 /* Check whether any event pending in the vStopped queue would prevent
6582 a global or process wildcard vCont action. Clear
6583 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6584 and clear the event inferior's may_wildcard_vcont flag if we can't
6585 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6588 check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard
)
6590 struct notif_client
*notif
= ¬if_client_stop
;
6592 remote_notif_get_pending_events (notif
);
6593 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6594 check_pending_event_prevents_wildcard_vcont_callback
,
6595 may_global_wildcard
);
6598 /* Remove stop replies in the queue if its pid is equal to the given
6602 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
6603 QUEUE_ITER (stop_reply_p
) *iter
,
6607 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6608 struct inferior
*inf
= (struct inferior
*) param
->input
;
6610 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
6612 stop_reply_xfree (event
);
6613 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6619 /* Discard all pending stop replies of inferior INF. */
6622 discard_pending_stop_replies (struct inferior
*inf
)
6624 struct queue_iter_param param
;
6625 struct stop_reply
*reply
;
6626 struct remote_state
*rs
= get_remote_state ();
6627 struct remote_notif_state
*rns
= rs
->notif_state
;
6629 /* This function can be notified when an inferior exists. When the
6630 target is not remote, the notification state is NULL. */
6631 if (rs
->remote_desc
== NULL
)
6634 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
6636 /* Discard the in-flight notification. */
6637 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
6639 stop_reply_xfree (reply
);
6640 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
6644 param
.output
= NULL
;
6645 /* Discard the stop replies we have already pulled with
6647 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6648 remove_stop_reply_for_inferior
, ¶m
);
6651 /* If its remote state is equal to the given remote state,
6652 remove EVENT from the stop reply queue. */
6655 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
6656 QUEUE_ITER (stop_reply_p
) *iter
,
6660 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6661 struct remote_state
*rs
= (struct remote_state
*) param
->input
;
6663 if (event
->rs
== rs
)
6665 stop_reply_xfree (event
);
6666 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6672 /* Discard the stop replies for RS in stop_reply_queue. */
6675 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
6677 struct queue_iter_param param
;
6680 param
.output
= NULL
;
6681 /* Discard the stop replies we have already pulled with
6683 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6684 remove_stop_reply_of_remote_state
, ¶m
);
6687 /* A parameter to pass data in and out. */
6690 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
6691 QUEUE_ITER (stop_reply_p
) *iter
,
6695 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6696 ptid_t
*ptid
= (ptid_t
*) param
->input
;
6698 if (ptid_match (event
->ptid
, *ptid
))
6700 param
->output
= event
;
6701 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6708 /* Remove the first reply in 'stop_reply_queue' which matches
6711 static struct stop_reply
*
6712 remote_notif_remove_queued_reply (ptid_t ptid
)
6714 struct queue_iter_param param
;
6716 param
.input
= &ptid
;
6717 param
.output
= NULL
;
6719 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6720 remote_notif_remove_once_on_match
, ¶m
);
6722 fprintf_unfiltered (gdb_stdlog
,
6723 "notif: discard queued event: 'Stop' in %s\n",
6724 target_pid_to_str (ptid
));
6726 return param
.output
;
6729 /* Look for a queued stop reply belonging to PTID. If one is found,
6730 remove it from the queue, and return it. Returns NULL if none is
6731 found. If there are still queued events left to process, tell the
6732 event loop to get back to target_wait soon. */
6734 static struct stop_reply
*
6735 queued_stop_reply (ptid_t ptid
)
6737 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
6739 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6740 /* There's still at least an event left. */
6741 mark_async_event_handler (remote_async_inferior_event_token
);
6746 /* Push a fully parsed stop reply in the stop reply queue. Since we
6747 know that we now have at least one queued event left to pass to the
6748 core side, tell the event loop to get back to target_wait soon. */
6751 push_stop_reply (struct stop_reply
*new_event
)
6753 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
6756 fprintf_unfiltered (gdb_stdlog
,
6757 "notif: push 'Stop' %s to queue %d\n",
6758 target_pid_to_str (new_event
->ptid
),
6759 QUEUE_length (stop_reply_p
,
6762 mark_async_event_handler (remote_async_inferior_event_token
);
6766 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
6767 QUEUE_ITER (stop_reply_p
) *iter
,
6768 struct stop_reply
*event
,
6771 ptid_t
*ptid
= (ptid_t
*) data
;
6773 return !(ptid_equal (*ptid
, event
->ptid
)
6774 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
6777 /* Returns true if we have a stop reply for PTID. */
6780 peek_stop_reply (ptid_t ptid
)
6782 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6783 stop_reply_match_ptid_and_ws
, &ptid
);
6786 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
6787 starting with P and ending with PEND matches PREFIX. */
6790 strprefix (const char *p
, const char *pend
, const char *prefix
)
6792 for ( ; p
< pend
; p
++, prefix
++)
6795 return *prefix
== '\0';
6798 /* Parse the stop reply in BUF. Either the function succeeds, and the
6799 result is stored in EVENT, or throws an error. */
6802 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
6804 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6809 event
->ptid
= null_ptid
;
6810 event
->rs
= get_remote_state ();
6811 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
6812 event
->ws
.value
.integer
= 0;
6813 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6814 event
->regcache
= NULL
;
6819 case 'T': /* Status with PC, SP, FP, ... */
6820 /* Expedited reply, containing Signal, {regno, reg} repeat. */
6821 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
6823 n... = register number
6824 r... = register contents
6827 p
= &buf
[3]; /* after Txx */
6833 p1
= strchr (p
, ':');
6835 error (_("Malformed packet(a) (missing colon): %s\n\
6839 error (_("Malformed packet(a) (missing register number): %s\n\
6843 /* Some "registers" are actually extended stop information.
6844 Note if you're adding a new entry here: GDB 7.9 and
6845 earlier assume that all register "numbers" that start
6846 with an hex digit are real register numbers. Make sure
6847 the server only sends such a packet if it knows the
6848 client understands it. */
6850 if (strprefix (p
, p1
, "thread"))
6851 event
->ptid
= read_ptid (++p1
, &p
);
6852 else if (strprefix (p
, p1
, "syscall_entry"))
6856 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
6857 p
= unpack_varlen_hex (++p1
, &sysno
);
6858 event
->ws
.value
.syscall_number
= (int) sysno
;
6860 else if (strprefix (p
, p1
, "syscall_return"))
6864 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
6865 p
= unpack_varlen_hex (++p1
, &sysno
);
6866 event
->ws
.value
.syscall_number
= (int) sysno
;
6868 else if (strprefix (p
, p1
, "watch")
6869 || strprefix (p
, p1
, "rwatch")
6870 || strprefix (p
, p1
, "awatch"))
6872 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
6873 p
= unpack_varlen_hex (++p1
, &addr
);
6874 event
->watch_data_address
= (CORE_ADDR
) addr
;
6876 else if (strprefix (p
, p1
, "swbreak"))
6878 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
6880 /* Make sure the stub doesn't forget to indicate support
6882 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
6883 error (_("Unexpected swbreak stop reason"));
6885 /* The value part is documented as "must be empty",
6886 though we ignore it, in case we ever decide to make
6887 use of it in a backward compatible way. */
6888 p
= strchrnul (p1
+ 1, ';');
6890 else if (strprefix (p
, p1
, "hwbreak"))
6892 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
6894 /* Make sure the stub doesn't forget to indicate support
6896 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
6897 error (_("Unexpected hwbreak stop reason"));
6900 p
= strchrnul (p1
+ 1, ';');
6902 else if (strprefix (p
, p1
, "library"))
6904 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
6905 p
= strchrnul (p1
+ 1, ';');
6907 else if (strprefix (p
, p1
, "replaylog"))
6909 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
6910 /* p1 will indicate "begin" or "end", but it makes
6911 no difference for now, so ignore it. */
6912 p
= strchrnul (p1
+ 1, ';');
6914 else if (strprefix (p
, p1
, "core"))
6918 p
= unpack_varlen_hex (++p1
, &c
);
6921 else if (strprefix (p
, p1
, "fork"))
6923 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6924 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
6926 else if (strprefix (p
, p1
, "vfork"))
6928 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6929 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
6931 else if (strprefix (p
, p1
, "vforkdone"))
6933 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
6934 p
= strchrnul (p1
+ 1, ';');
6936 else if (strprefix (p
, p1
, "exec"))
6939 char pathname
[PATH_MAX
];
6942 /* Determine the length of the execd pathname. */
6943 p
= unpack_varlen_hex (++p1
, &ignored
);
6944 pathlen
= (p
- p1
) / 2;
6946 /* Save the pathname for event reporting and for
6947 the next run command. */
6948 hex2bin (p1
, (gdb_byte
*) pathname
, pathlen
);
6949 pathname
[pathlen
] = '\0';
6951 /* This is freed during event handling. */
6952 event
->ws
.value
.execd_pathname
= xstrdup (pathname
);
6953 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
6955 /* Skip the registers included in this packet, since
6956 they may be for an architecture different from the
6957 one used by the original program. */
6960 else if (strprefix (p
, p1
, "create"))
6962 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
6963 p
= strchrnul (p1
+ 1, ';');
6972 p
= strchrnul (p1
+ 1, ';');
6977 /* Maybe a real ``P'' register number. */
6978 p_temp
= unpack_varlen_hex (p
, &pnum
);
6979 /* If the first invalid character is the colon, we got a
6980 register number. Otherwise, it's an unknown stop
6984 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
6985 cached_reg_t cached_reg
;
6986 struct gdbarch
*gdbarch
= target_gdbarch ();
6989 error (_("Remote sent bad register number %s: %s\n\
6991 hex_string (pnum
), p
, buf
);
6993 cached_reg
.num
= reg
->regnum
;
6994 cached_reg
.data
= (gdb_byte
*)
6995 xmalloc (register_size (gdbarch
, reg
->regnum
));
6998 fieldsize
= hex2bin (p
, cached_reg
.data
,
6999 register_size (gdbarch
, reg
->regnum
));
7001 if (fieldsize
< register_size (gdbarch
, reg
->regnum
))
7002 warning (_("Remote reply is too short: %s"), buf
);
7004 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
7008 /* Not a number. Silently skip unknown optional
7010 p
= strchrnul (p1
+ 1, ';');
7015 error (_("Remote register badly formatted: %s\nhere: %s"),
7020 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7024 case 'S': /* Old style status, just signal only. */
7028 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7029 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7030 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7031 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7033 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7036 case 'w': /* Thread exited. */
7041 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7042 p
= unpack_varlen_hex (&buf
[1], &value
);
7043 event
->ws
.value
.integer
= value
;
7045 error (_("stop reply packet badly formatted: %s"), buf
);
7046 event
->ptid
= read_ptid (++p
, NULL
);
7049 case 'W': /* Target exited. */
7056 /* GDB used to accept only 2 hex chars here. Stubs should
7057 only send more if they detect GDB supports multi-process
7059 p
= unpack_varlen_hex (&buf
[1], &value
);
7063 /* The remote process exited. */
7064 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7065 event
->ws
.value
.integer
= value
;
7069 /* The remote process exited with a signal. */
7070 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7071 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7072 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7074 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7077 /* If no process is specified, assume inferior_ptid. */
7078 pid
= ptid_get_pid (inferior_ptid
);
7087 else if (startswith (p
, "process:"))
7091 p
+= sizeof ("process:") - 1;
7092 unpack_varlen_hex (p
, &upid
);
7096 error (_("unknown stop reply packet: %s"), buf
);
7099 error (_("unknown stop reply packet: %s"), buf
);
7100 event
->ptid
= pid_to_ptid (pid
);
7104 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7105 event
->ptid
= minus_one_ptid
;
7109 if (target_is_non_stop_p () && ptid_equal (event
->ptid
, null_ptid
))
7110 error (_("No process or thread specified in stop reply: %s"), buf
);
7113 /* When the stub wants to tell GDB about a new notification reply, it
7114 sends a notification (%Stop, for example). Those can come it at
7115 any time, hence, we have to make sure that any pending
7116 putpkt/getpkt sequence we're making is finished, before querying
7117 the stub for more events with the corresponding ack command
7118 (vStopped, for example). E.g., if we started a vStopped sequence
7119 immediately upon receiving the notification, something like this
7127 1.6) <-- (registers reply to step #1.3)
7129 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7132 To solve this, whenever we parse a %Stop notification successfully,
7133 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7134 doing whatever we were doing:
7140 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7141 2.5) <-- (registers reply to step #2.3)
7143 Eventualy after step #2.5, we return to the event loop, which
7144 notices there's an event on the
7145 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7146 associated callback --- the function below. At this point, we're
7147 always safe to start a vStopped sequence. :
7150 2.7) <-- T05 thread:2
7156 remote_notif_get_pending_events (struct notif_client
*nc
)
7158 struct remote_state
*rs
= get_remote_state ();
7160 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7163 fprintf_unfiltered (gdb_stdlog
,
7164 "notif: process: '%s' ack pending event\n",
7168 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
7169 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7173 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7174 if (strcmp (rs
->buf
, "OK") == 0)
7177 remote_notif_ack (nc
, rs
->buf
);
7183 fprintf_unfiltered (gdb_stdlog
,
7184 "notif: process: '%s' no pending reply\n",
7189 /* Called when it is decided that STOP_REPLY holds the info of the
7190 event that is to be returned to the core. This function always
7191 destroys STOP_REPLY. */
7194 process_stop_reply (struct stop_reply
*stop_reply
,
7195 struct target_waitstatus
*status
)
7199 *status
= stop_reply
->ws
;
7200 ptid
= stop_reply
->ptid
;
7202 /* If no thread/process was reported by the stub, assume the current
7204 if (ptid_equal (ptid
, null_ptid
))
7205 ptid
= inferior_ptid
;
7207 if (status
->kind
!= TARGET_WAITKIND_EXITED
7208 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7209 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7211 struct private_thread_info
*remote_thr
;
7213 /* Expedited registers. */
7214 if (stop_reply
->regcache
)
7216 struct regcache
*regcache
7217 = get_thread_arch_regcache (ptid
, target_gdbarch ());
7222 VEC_iterate (cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
7225 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
7229 VEC_free (cached_reg_t
, stop_reply
->regcache
);
7232 remote_notice_new_inferior (ptid
, 0);
7233 remote_thr
= get_private_info_ptid (ptid
);
7234 remote_thr
->core
= stop_reply
->core
;
7235 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7236 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7237 remote_thr
->vcont_resumed
= 0;
7240 stop_reply_xfree (stop_reply
);
7244 /* The non-stop mode version of target_wait. */
7247 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7249 struct remote_state
*rs
= get_remote_state ();
7250 struct stop_reply
*stop_reply
;
7254 /* If in non-stop mode, get out of getpkt even if a
7255 notification is received. */
7257 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7258 0 /* forever */, &is_notif
);
7261 if (ret
!= -1 && !is_notif
)
7264 case 'E': /* Error of some sort. */
7265 /* We're out of sync with the target now. Did it continue
7266 or not? We can't tell which thread it was in non-stop,
7267 so just ignore this. */
7268 warning (_("Remote failure reply: %s"), rs
->buf
);
7270 case 'O': /* Console output. */
7271 remote_console_output (rs
->buf
+ 1);
7274 warning (_("Invalid remote reply: %s"), rs
->buf
);
7278 /* Acknowledge a pending stop reply that may have arrived in the
7280 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7281 remote_notif_get_pending_events (¬if_client_stop
);
7283 /* If indeed we noticed a stop reply, we're done. */
7284 stop_reply
= queued_stop_reply (ptid
);
7285 if (stop_reply
!= NULL
)
7286 return process_stop_reply (stop_reply
, status
);
7288 /* Still no event. If we're just polling for an event, then
7289 return to the event loop. */
7290 if (options
& TARGET_WNOHANG
)
7292 status
->kind
= TARGET_WAITKIND_IGNORE
;
7293 return minus_one_ptid
;
7296 /* Otherwise do a blocking wait. */
7297 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7298 1 /* forever */, &is_notif
);
7302 /* Wait until the remote machine stops, then return, storing status in
7303 STATUS just as `wait' would. */
7306 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7308 struct remote_state
*rs
= get_remote_state ();
7309 ptid_t event_ptid
= null_ptid
;
7311 struct stop_reply
*stop_reply
;
7315 status
->kind
= TARGET_WAITKIND_IGNORE
;
7316 status
->value
.integer
= 0;
7318 stop_reply
= queued_stop_reply (ptid
);
7319 if (stop_reply
!= NULL
)
7320 return process_stop_reply (stop_reply
, status
);
7322 if (rs
->cached_wait_status
)
7323 /* Use the cached wait status, but only once. */
7324 rs
->cached_wait_status
= 0;
7329 int forever
= ((options
& TARGET_WNOHANG
) == 0
7330 && wait_forever_enabled_p
);
7332 if (!rs
->waiting_for_stop_reply
)
7334 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7335 return minus_one_ptid
;
7338 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7339 _never_ wait for ever -> test on target_is_async_p().
7340 However, before we do that we need to ensure that the caller
7341 knows how to take the target into/out of async mode. */
7342 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7343 forever
, &is_notif
);
7345 /* GDB gets a notification. Return to core as this event is
7347 if (ret
!= -1 && is_notif
)
7348 return minus_one_ptid
;
7350 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7351 return minus_one_ptid
;
7356 /* Assume that the target has acknowledged Ctrl-C unless we receive
7357 an 'F' or 'O' packet. */
7358 if (buf
[0] != 'F' && buf
[0] != 'O')
7359 rs
->ctrlc_pending_p
= 0;
7363 case 'E': /* Error of some sort. */
7364 /* We're out of sync with the target now. Did it continue or
7365 not? Not is more likely, so report a stop. */
7366 rs
->waiting_for_stop_reply
= 0;
7368 warning (_("Remote failure reply: %s"), buf
);
7369 status
->kind
= TARGET_WAITKIND_STOPPED
;
7370 status
->value
.sig
= GDB_SIGNAL_0
;
7372 case 'F': /* File-I/O request. */
7373 /* GDB may access the inferior memory while handling the File-I/O
7374 request, but we don't want GDB accessing memory while waiting
7375 for a stop reply. See the comments in putpkt_binary. Set
7376 waiting_for_stop_reply to 0 temporarily. */
7377 rs
->waiting_for_stop_reply
= 0;
7378 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
7379 rs
->ctrlc_pending_p
= 0;
7380 /* GDB handled the File-I/O request, and the target is running
7381 again. Keep waiting for events. */
7382 rs
->waiting_for_stop_reply
= 1;
7384 case 'N': case 'T': case 'S': case 'X': case 'W':
7386 struct stop_reply
*stop_reply
;
7388 /* There is a stop reply to handle. */
7389 rs
->waiting_for_stop_reply
= 0;
7392 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
7395 event_ptid
= process_stop_reply (stop_reply
, status
);
7398 case 'O': /* Console output. */
7399 remote_console_output (buf
+ 1);
7402 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7404 /* Zero length reply means that we tried 'S' or 'C' and the
7405 remote system doesn't support it. */
7406 target_terminal_ours_for_output ();
7408 ("Can't send signals to this remote system. %s not sent.\n",
7409 gdb_signal_to_name (rs
->last_sent_signal
));
7410 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7411 target_terminal_inferior ();
7413 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7417 /* else fallthrough */
7419 warning (_("Invalid remote reply: %s"), buf
);
7423 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7424 return minus_one_ptid
;
7425 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7427 /* Nothing interesting happened. If we're doing a non-blocking
7428 poll, we're done. Otherwise, go back to waiting. */
7429 if (options
& TARGET_WNOHANG
)
7430 return minus_one_ptid
;
7434 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7435 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7437 if (!ptid_equal (event_ptid
, null_ptid
))
7438 record_currthread (rs
, event_ptid
);
7440 event_ptid
= inferior_ptid
;
7443 /* A process exit. Invalidate our notion of current thread. */
7444 record_currthread (rs
, minus_one_ptid
);
7449 /* Wait until the remote machine stops, then return, storing status in
7450 STATUS just as `wait' would. */
7453 remote_wait (struct target_ops
*ops
,
7454 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7458 if (target_is_non_stop_p ())
7459 event_ptid
= remote_wait_ns (ptid
, status
, options
);
7461 event_ptid
= remote_wait_as (ptid
, status
, options
);
7463 if (target_is_async_p ())
7465 /* If there are are events left in the queue tell the event loop
7467 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
7468 mark_async_event_handler (remote_async_inferior_event_token
);
7474 /* Fetch a single register using a 'p' packet. */
7477 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
7479 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7480 struct remote_state
*rs
= get_remote_state ();
7482 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7485 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7488 if (reg
->pnum
== -1)
7493 p
+= hexnumstr (p
, reg
->pnum
);
7496 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7500 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
7504 case PACKET_UNKNOWN
:
7507 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7508 gdbarch_register_name (get_regcache_arch (regcache
),
7513 /* If this register is unfetchable, tell the regcache. */
7516 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7520 /* Otherwise, parse and supply the value. */
7526 error (_("fetch_register_using_p: early buf termination"));
7528 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7531 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
7535 /* Fetch the registers included in the target's 'g' packet. */
7538 send_g_packet (void)
7540 struct remote_state
*rs
= get_remote_state ();
7543 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
7544 remote_send (&rs
->buf
, &rs
->buf_size
);
7546 /* We can get out of synch in various cases. If the first character
7547 in the buffer is not a hex character, assume that has happened
7548 and try to fetch another packet to read. */
7549 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7550 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7551 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7552 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7555 fprintf_unfiltered (gdb_stdlog
,
7556 "Bad register packet; fetching a new packet\n");
7557 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7560 buf_len
= strlen (rs
->buf
);
7562 /* Sanity check the received packet. */
7563 if (buf_len
% 2 != 0)
7564 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
7570 process_g_packet (struct regcache
*regcache
)
7572 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7573 struct remote_state
*rs
= get_remote_state ();
7574 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7579 buf_len
= strlen (rs
->buf
);
7581 /* Further sanity checks, with knowledge of the architecture. */
7582 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7583 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
7585 /* Save the size of the packet sent to us by the target. It is used
7586 as a heuristic when determining the max size of packets that the
7587 target can safely receive. */
7588 if (rsa
->actual_register_packet_size
== 0)
7589 rsa
->actual_register_packet_size
= buf_len
;
7591 /* If this is smaller than we guessed the 'g' packet would be,
7592 update our records. A 'g' reply that doesn't include a register's
7593 value implies either that the register is not available, or that
7594 the 'p' packet must be used. */
7595 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7597 long sizeof_g_packet
= buf_len
/ 2;
7599 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7601 long offset
= rsa
->regs
[i
].offset
;
7602 long reg_size
= register_size (gdbarch
, i
);
7604 if (rsa
->regs
[i
].pnum
== -1)
7607 if (offset
>= sizeof_g_packet
)
7608 rsa
->regs
[i
].in_g_packet
= 0;
7609 else if (offset
+ reg_size
> sizeof_g_packet
)
7610 error (_("Truncated register %d in remote 'g' packet"), i
);
7612 rsa
->regs
[i
].in_g_packet
= 1;
7615 /* Looks valid enough, we can assume this is the correct length
7616 for a 'g' packet. It's important not to adjust
7617 rsa->sizeof_g_packet if we have truncated registers otherwise
7618 this "if" won't be run the next time the method is called
7619 with a packet of the same size and one of the internal errors
7620 below will trigger instead. */
7621 rsa
->sizeof_g_packet
= sizeof_g_packet
;
7624 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
7626 /* Unimplemented registers read as all bits zero. */
7627 memset (regs
, 0, rsa
->sizeof_g_packet
);
7629 /* Reply describes registers byte by byte, each byte encoded as two
7630 hex characters. Suck them all up, then supply them to the
7631 register cacheing/storage mechanism. */
7634 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
7636 if (p
[0] == 0 || p
[1] == 0)
7637 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
7638 internal_error (__FILE__
, __LINE__
,
7639 _("unexpected end of 'g' packet reply"));
7641 if (p
[0] == 'x' && p
[1] == 'x')
7642 regs
[i
] = 0; /* 'x' */
7644 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7648 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7650 struct packet_reg
*r
= &rsa
->regs
[i
];
7651 long reg_size
= register_size (gdbarch
, i
);
7655 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
))
7656 /* This shouldn't happen - we adjusted in_g_packet above. */
7657 internal_error (__FILE__
, __LINE__
,
7658 _("unexpected end of 'g' packet reply"));
7659 else if (rs
->buf
[r
->offset
* 2] == 'x')
7661 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
7662 /* The register isn't available, mark it as such (at
7663 the same time setting the value to zero). */
7664 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
7667 regcache_raw_supply (regcache
, r
->regnum
,
7674 fetch_registers_using_g (struct regcache
*regcache
)
7677 process_g_packet (regcache
);
7680 /* Make the remote selected traceframe match GDB's selected
7684 set_remote_traceframe (void)
7687 struct remote_state
*rs
= get_remote_state ();
7689 if (rs
->remote_traceframe_number
== get_traceframe_number ())
7692 /* Avoid recursion, remote_trace_find calls us again. */
7693 rs
->remote_traceframe_number
= get_traceframe_number ();
7695 newnum
= target_trace_find (tfind_number
,
7696 get_traceframe_number (), 0, 0, NULL
);
7698 /* Should not happen. If it does, all bets are off. */
7699 if (newnum
!= get_traceframe_number ())
7700 warning (_("could not set remote traceframe"));
7704 remote_fetch_registers (struct target_ops
*ops
,
7705 struct regcache
*regcache
, int regnum
)
7707 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7710 set_remote_traceframe ();
7711 set_general_thread (regcache_get_ptid (regcache
));
7715 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7717 gdb_assert (reg
!= NULL
);
7719 /* If this register might be in the 'g' packet, try that first -
7720 we are likely to read more than one register. If this is the
7721 first 'g' packet, we might be overly optimistic about its
7722 contents, so fall back to 'p'. */
7723 if (reg
->in_g_packet
)
7725 fetch_registers_using_g (regcache
);
7726 if (reg
->in_g_packet
)
7730 if (fetch_register_using_p (regcache
, reg
))
7733 /* This register is not available. */
7734 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7739 fetch_registers_using_g (regcache
);
7741 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7742 if (!rsa
->regs
[i
].in_g_packet
)
7743 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
7745 /* This register is not available. */
7746 regcache_raw_supply (regcache
, i
, NULL
);
7750 /* Prepare to store registers. Since we may send them all (using a
7751 'G' request), we have to read out the ones we don't want to change
7755 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
7757 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7760 /* Make sure the entire registers array is valid. */
7761 switch (packet_support (PACKET_P
))
7763 case PACKET_DISABLE
:
7764 case PACKET_SUPPORT_UNKNOWN
:
7765 /* Make sure all the necessary registers are cached. */
7766 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7767 if (rsa
->regs
[i
].in_g_packet
)
7768 regcache_raw_update (regcache
, rsa
->regs
[i
].regnum
);
7775 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
7776 packet was not recognized. */
7779 store_register_using_P (const struct regcache
*regcache
,
7780 struct packet_reg
*reg
)
7782 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7783 struct remote_state
*rs
= get_remote_state ();
7784 /* Try storing a single register. */
7785 char *buf
= rs
->buf
;
7786 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7789 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
7792 if (reg
->pnum
== -1)
7795 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
7796 p
= buf
+ strlen (buf
);
7797 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
7798 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
7800 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7802 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
7807 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
7808 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
7809 case PACKET_UNKNOWN
:
7812 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
7816 /* Store register REGNUM, or all registers if REGNUM == -1, from the
7817 contents of the register cache buffer. FIXME: ignores errors. */
7820 store_registers_using_G (const struct regcache
*regcache
)
7822 struct remote_state
*rs
= get_remote_state ();
7823 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7827 /* Extract all the registers in the regcache copying them into a
7832 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
7833 memset (regs
, 0, rsa
->sizeof_g_packet
);
7834 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7836 struct packet_reg
*r
= &rsa
->regs
[i
];
7839 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
7843 /* Command describes registers byte by byte,
7844 each byte encoded as two hex characters. */
7847 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
7849 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7850 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7851 error (_("Could not write registers; remote failure reply '%s'"),
7855 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7856 of the register cache buffer. FIXME: ignores errors. */
7859 remote_store_registers (struct target_ops
*ops
,
7860 struct regcache
*regcache
, int regnum
)
7862 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7865 set_remote_traceframe ();
7866 set_general_thread (regcache_get_ptid (regcache
));
7870 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7872 gdb_assert (reg
!= NULL
);
7874 /* Always prefer to store registers using the 'P' packet if
7875 possible; we often change only a small number of registers.
7876 Sometimes we change a larger number; we'd need help from a
7877 higher layer to know to use 'G'. */
7878 if (store_register_using_P (regcache
, reg
))
7881 /* For now, don't complain if we have no way to write the
7882 register. GDB loses track of unavailable registers too
7883 easily. Some day, this may be an error. We don't have
7884 any way to read the register, either... */
7885 if (!reg
->in_g_packet
)
7888 store_registers_using_G (regcache
);
7892 store_registers_using_G (regcache
);
7894 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7895 if (!rsa
->regs
[i
].in_g_packet
)
7896 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
7897 /* See above for why we do not issue an error here. */
7902 /* Return the number of hex digits in num. */
7905 hexnumlen (ULONGEST num
)
7909 for (i
= 0; num
!= 0; i
++)
7912 return std::max (i
, 1);
7915 /* Set BUF to the minimum number of hex digits representing NUM. */
7918 hexnumstr (char *buf
, ULONGEST num
)
7920 int len
= hexnumlen (num
);
7922 return hexnumnstr (buf
, num
, len
);
7926 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7929 hexnumnstr (char *buf
, ULONGEST num
, int width
)
7935 for (i
= width
- 1; i
>= 0; i
--)
7937 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
7944 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7947 remote_address_masked (CORE_ADDR addr
)
7949 unsigned int address_size
= remote_address_size
;
7951 /* If "remoteaddresssize" was not set, default to target address size. */
7953 address_size
= gdbarch_addr_bit (target_gdbarch ());
7955 if (address_size
> 0
7956 && address_size
< (sizeof (ULONGEST
) * 8))
7958 /* Only create a mask when that mask can safely be constructed
7959 in a ULONGEST variable. */
7962 mask
= (mask
<< address_size
) - 1;
7968 /* Determine whether the remote target supports binary downloading.
7969 This is accomplished by sending a no-op memory write of zero length
7970 to the target at the specified address. It does not suffice to send
7971 the whole packet, since many stubs strip the eighth bit and
7972 subsequently compute a wrong checksum, which causes real havoc with
7975 NOTE: This can still lose if the serial line is not eight-bit
7976 clean. In cases like this, the user should clear "remote
7980 check_binary_download (CORE_ADDR addr
)
7982 struct remote_state
*rs
= get_remote_state ();
7984 switch (packet_support (PACKET_X
))
7986 case PACKET_DISABLE
:
7990 case PACKET_SUPPORT_UNKNOWN
:
7996 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7998 p
+= hexnumstr (p
, (ULONGEST
) 0);
8002 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8003 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8005 if (rs
->buf
[0] == '\0')
8008 fprintf_unfiltered (gdb_stdlog
,
8009 "binary downloading NOT "
8010 "supported by target\n");
8011 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8016 fprintf_unfiltered (gdb_stdlog
,
8017 "binary downloading supported by target\n");
8018 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8025 /* Helper function to resize the payload in order to try to get a good
8026 alignment. We try to write an amount of data such that the next write will
8027 start on an address aligned on REMOTE_ALIGN_WRITES. */
8030 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8032 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8035 /* Write memory data directly to the remote machine.
8036 This does not inform the data cache; the data cache uses this.
8037 HEADER is the starting part of the packet.
8038 MEMADDR is the address in the remote memory space.
8039 MYADDR is the address of the buffer in our space.
8040 LEN_UNITS is the number of addressable units to write.
8041 UNIT_SIZE is the length in bytes of an addressable unit.
8042 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8043 should send data as binary ('X'), or hex-encoded ('M').
8045 The function creates packet of the form
8046 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8048 where encoding of <DATA> is terminated by PACKET_FORMAT.
8050 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8053 Return the transferred status, error or OK (an
8054 'enum target_xfer_status' value). Save the number of addressable units
8055 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8057 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8058 exchange between gdb and the stub could look like (?? in place of the
8064 -> $M1000,3:eeeeffffeeee#??
8068 <- eeeeffffeeeedddd */
8070 static enum target_xfer_status
8071 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8072 const gdb_byte
*myaddr
, ULONGEST len_units
,
8073 int unit_size
, ULONGEST
*xfered_len_units
,
8074 char packet_format
, int use_length
)
8076 struct remote_state
*rs
= get_remote_state ();
8082 int payload_capacity_bytes
;
8083 int payload_length_bytes
;
8085 if (packet_format
!= 'X' && packet_format
!= 'M')
8086 internal_error (__FILE__
, __LINE__
,
8087 _("remote_write_bytes_aux: bad packet format"));
8090 return TARGET_XFER_EOF
;
8092 payload_capacity_bytes
= get_memory_write_packet_size ();
8094 /* The packet buffer will be large enough for the payload;
8095 get_memory_packet_size ensures this. */
8098 /* Compute the size of the actual payload by subtracting out the
8099 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8101 payload_capacity_bytes
-= strlen ("$,:#NN");
8103 /* The comma won't be used. */
8104 payload_capacity_bytes
+= 1;
8105 payload_capacity_bytes
-= strlen (header
);
8106 payload_capacity_bytes
-= hexnumlen (memaddr
);
8108 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8110 strcat (rs
->buf
, header
);
8111 p
= rs
->buf
+ strlen (header
);
8113 /* Compute a best guess of the number of bytes actually transfered. */
8114 if (packet_format
== 'X')
8116 /* Best guess at number of bytes that will fit. */
8117 todo_units
= std::min (len_units
,
8118 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8120 payload_capacity_bytes
-= hexnumlen (todo_units
);
8121 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8125 /* Number of bytes that will fit. */
8127 = std::min (len_units
,
8128 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8130 payload_capacity_bytes
-= hexnumlen (todo_units
);
8131 todo_units
= std::min (todo_units
,
8132 (payload_capacity_bytes
/ unit_size
) / 2);
8135 if (todo_units
<= 0)
8136 internal_error (__FILE__
, __LINE__
,
8137 _("minimum packet size too small to write data"));
8139 /* If we already need another packet, then try to align the end
8140 of this packet to a useful boundary. */
8141 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8142 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8144 /* Append "<memaddr>". */
8145 memaddr
= remote_address_masked (memaddr
);
8146 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8153 /* Append the length and retain its location and size. It may need to be
8154 adjusted once the packet body has been created. */
8156 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8164 /* Append the packet body. */
8165 if (packet_format
== 'X')
8167 /* Binary mode. Send target system values byte by byte, in
8168 increasing byte addresses. Only escape certain critical
8170 payload_length_bytes
=
8171 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8172 &units_written
, payload_capacity_bytes
);
8174 /* If not all TODO units fit, then we'll need another packet. Make
8175 a second try to keep the end of the packet aligned. Don't do
8176 this if the packet is tiny. */
8177 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8181 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8183 if (new_todo_units
!= units_written
)
8184 payload_length_bytes
=
8185 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8186 (gdb_byte
*) p
, &units_written
,
8187 payload_capacity_bytes
);
8190 p
+= payload_length_bytes
;
8191 if (use_length
&& units_written
< todo_units
)
8193 /* Escape chars have filled up the buffer prematurely,
8194 and we have actually sent fewer units than planned.
8195 Fix-up the length field of the packet. Use the same
8196 number of characters as before. */
8197 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8199 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8204 /* Normal mode: Send target system values byte by byte, in
8205 increasing byte addresses. Each byte is encoded as a two hex
8207 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8208 units_written
= todo_units
;
8211 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8212 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8214 if (rs
->buf
[0] == 'E')
8215 return TARGET_XFER_E_IO
;
8217 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8218 send fewer units than we'd planned. */
8219 *xfered_len_units
= (ULONGEST
) units_written
;
8220 return TARGET_XFER_OK
;
8223 /* Write memory data directly to the remote machine.
8224 This does not inform the data cache; the data cache uses this.
8225 MEMADDR is the address in the remote memory space.
8226 MYADDR is the address of the buffer in our space.
8227 LEN is the number of bytes.
8229 Return the transferred status, error or OK (an
8230 'enum target_xfer_status' value). Save the number of bytes
8231 transferred in *XFERED_LEN. Only transfer a single packet. */
8233 static enum target_xfer_status
8234 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
8235 int unit_size
, ULONGEST
*xfered_len
)
8237 const char *packet_format
= NULL
;
8239 /* Check whether the target supports binary download. */
8240 check_binary_download (memaddr
);
8242 switch (packet_support (PACKET_X
))
8245 packet_format
= "X";
8247 case PACKET_DISABLE
:
8248 packet_format
= "M";
8250 case PACKET_SUPPORT_UNKNOWN
:
8251 internal_error (__FILE__
, __LINE__
,
8252 _("remote_write_bytes: bad internal state"));
8254 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8257 return remote_write_bytes_aux (packet_format
,
8258 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8259 packet_format
[0], 1);
8262 /* Read memory data directly from the remote machine.
8263 This does not use the data cache; the data cache uses this.
8264 MEMADDR is the address in the remote memory space.
8265 MYADDR is the address of the buffer in our space.
8266 LEN_UNITS is the number of addressable memory units to read..
8267 UNIT_SIZE is the length in bytes of an addressable unit.
8269 Return the transferred status, error or OK (an
8270 'enum target_xfer_status' value). Save the number of bytes
8271 transferred in *XFERED_LEN_UNITS.
8273 See the comment of remote_write_bytes_aux for an example of
8274 memory read/write exchange between gdb and the stub. */
8276 static enum target_xfer_status
8277 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
8278 int unit_size
, ULONGEST
*xfered_len_units
)
8280 struct remote_state
*rs
= get_remote_state ();
8281 int buf_size_bytes
; /* Max size of packet output buffer. */
8286 buf_size_bytes
= get_memory_read_packet_size ();
8287 /* The packet buffer will be large enough for the payload;
8288 get_memory_packet_size ensures this. */
8290 /* Number of units that will fit. */
8291 todo_units
= std::min (len_units
,
8292 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8294 /* Construct "m"<memaddr>","<len>". */
8295 memaddr
= remote_address_masked (memaddr
);
8298 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8300 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8303 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8304 if (rs
->buf
[0] == 'E'
8305 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8306 && rs
->buf
[3] == '\0')
8307 return TARGET_XFER_E_IO
;
8308 /* Reply describes memory byte by byte, each byte encoded as two hex
8311 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8312 /* Return what we have. Let higher layers handle partial reads. */
8313 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8314 return TARGET_XFER_OK
;
8317 /* Using the set of read-only target sections of remote, read live
8320 For interface/parameters/return description see target.h,
8323 static enum target_xfer_status
8324 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
8325 ULONGEST memaddr
, ULONGEST len
,
8326 int unit_size
, ULONGEST
*xfered_len
)
8328 struct target_section
*secp
;
8329 struct target_section_table
*table
;
8331 secp
= target_section_by_addr (ops
, memaddr
);
8333 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8334 secp
->the_bfd_section
)
8337 struct target_section
*p
;
8338 ULONGEST memend
= memaddr
+ len
;
8340 table
= target_get_section_table (ops
);
8342 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8344 if (memaddr
>= p
->addr
)
8346 if (memend
<= p
->endaddr
)
8348 /* Entire transfer is within this section. */
8349 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8352 else if (memaddr
>= p
->endaddr
)
8354 /* This section ends before the transfer starts. */
8359 /* This section overlaps the transfer. Just do half. */
8360 len
= p
->endaddr
- memaddr
;
8361 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8368 return TARGET_XFER_EOF
;
8371 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8372 first if the requested memory is unavailable in traceframe.
8373 Otherwise, fall back to remote_read_bytes_1. */
8375 static enum target_xfer_status
8376 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
8377 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8378 ULONGEST
*xfered_len
)
8381 return TARGET_XFER_EOF
;
8383 if (get_traceframe_number () != -1)
8385 VEC(mem_range_s
) *available
;
8387 /* If we fail to get the set of available memory, then the
8388 target does not support querying traceframe info, and so we
8389 attempt reading from the traceframe anyway (assuming the
8390 target implements the old QTro packet then). */
8391 if (traceframe_available_memory (&available
, memaddr
, len
))
8393 struct cleanup
*old_chain
;
8395 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
8397 if (VEC_empty (mem_range_s
, available
)
8398 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
8400 enum target_xfer_status res
;
8402 /* Don't read into the traceframe's available
8404 if (!VEC_empty (mem_range_s
, available
))
8406 LONGEST oldlen
= len
;
8408 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
8409 gdb_assert (len
<= oldlen
);
8412 do_cleanups (old_chain
);
8414 /* This goes through the topmost target again. */
8415 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
8416 len
, unit_size
, xfered_len
);
8417 if (res
== TARGET_XFER_OK
)
8418 return TARGET_XFER_OK
;
8421 /* No use trying further, we know some memory starting
8422 at MEMADDR isn't available. */
8424 return TARGET_XFER_UNAVAILABLE
;
8428 /* Don't try to read more than how much is available, in
8429 case the target implements the deprecated QTro packet to
8430 cater for older GDBs (the target's knowledge of read-only
8431 sections may be outdated by now). */
8432 len
= VEC_index (mem_range_s
, available
, 0)->length
;
8434 do_cleanups (old_chain
);
8438 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8443 /* Sends a packet with content determined by the printf format string
8444 FORMAT and the remaining arguments, then gets the reply. Returns
8445 whether the packet was a success, a failure, or unknown. */
8447 static enum packet_result
remote_send_printf (const char *format
, ...)
8448 ATTRIBUTE_PRINTF (1, 2);
8450 static enum packet_result
8451 remote_send_printf (const char *format
, ...)
8453 struct remote_state
*rs
= get_remote_state ();
8454 int max_size
= get_remote_packet_size ();
8457 va_start (ap
, format
);
8460 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
8461 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8463 if (putpkt (rs
->buf
) < 0)
8464 error (_("Communication problem with target."));
8467 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8469 return packet_check_result (rs
->buf
);
8473 restore_remote_timeout (void *p
)
8475 int value
= *(int *)p
;
8477 remote_timeout
= value
;
8480 /* Flash writing can take quite some time. We'll set
8481 effectively infinite timeout for flash operations.
8482 In future, we'll need to decide on a better approach. */
8483 static const int remote_flash_timeout
= 1000;
8486 remote_flash_erase (struct target_ops
*ops
,
8487 ULONGEST address
, LONGEST length
)
8489 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8490 int saved_remote_timeout
= remote_timeout
;
8491 enum packet_result ret
;
8492 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8493 &saved_remote_timeout
);
8495 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"));
8510 do_cleanups (back_to
);
8513 static enum target_xfer_status
8514 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
8515 ULONGEST length
, ULONGEST
*xfered_len
,
8516 const gdb_byte
*data
)
8518 int saved_remote_timeout
= remote_timeout
;
8519 enum target_xfer_status ret
;
8520 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8521 &saved_remote_timeout
);
8523 remote_timeout
= remote_flash_timeout
;
8524 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8526 do_cleanups (back_to
);
8532 remote_flash_done (struct target_ops
*ops
)
8534 int saved_remote_timeout
= remote_timeout
;
8536 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8537 &saved_remote_timeout
);
8539 remote_timeout
= remote_flash_timeout
;
8540 ret
= remote_send_printf ("vFlashDone");
8541 do_cleanups (back_to
);
8545 case PACKET_UNKNOWN
:
8546 error (_("Remote target does not support vFlashDone"));
8548 error (_("Error finishing flash operation"));
8555 remote_files_info (struct target_ops
*ignore
)
8557 puts_filtered ("Debugging a target over a serial line.\n");
8560 /* Stuff for dealing with the packets which are part of this protocol.
8561 See comment at top of file for details. */
8563 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8564 error to higher layers. Called when a serial error is detected.
8565 The exception message is STRING, followed by a colon and a blank,
8566 the system error message for errno at function entry and final dot
8567 for output compatibility with throw_perror_with_name. */
8570 unpush_and_perror (const char *string
)
8572 int saved_errno
= errno
;
8574 remote_unpush_target ();
8575 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8576 safe_strerror (saved_errno
));
8579 /* Read a single character from the remote end. The current quit
8580 handler is overridden to avoid quitting in the middle of packet
8581 sequence, as that would break communication with the remote server.
8582 See remote_serial_quit_handler for more detail. */
8585 readchar (int timeout
)
8588 struct remote_state
*rs
= get_remote_state ();
8589 struct cleanup
*old_chain
;
8591 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8593 rs
->got_ctrlc_during_io
= 0;
8595 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8597 if (rs
->got_ctrlc_during_io
)
8600 do_cleanups (old_chain
);
8605 switch ((enum serial_rc
) ch
)
8608 remote_unpush_target ();
8609 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8612 unpush_and_perror (_("Remote communication error. "
8613 "Target disconnected."));
8615 case SERIAL_TIMEOUT
:
8621 /* Wrapper for serial_write that closes the target and throws if
8622 writing fails. The current quit handler is overridden to avoid
8623 quitting in the middle of packet sequence, as that would break
8624 communication with the remote server. See
8625 remote_serial_quit_handler for more detail. */
8628 remote_serial_write (const char *str
, int len
)
8630 struct remote_state
*rs
= get_remote_state ();
8631 struct cleanup
*old_chain
;
8633 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8635 rs
->got_ctrlc_during_io
= 0;
8637 if (serial_write (rs
->remote_desc
, str
, len
))
8639 unpush_and_perror (_("Remote communication error. "
8640 "Target disconnected."));
8643 if (rs
->got_ctrlc_during_io
)
8646 do_cleanups (old_chain
);
8649 /* Send the command in *BUF to the remote machine, and read the reply
8650 into *BUF. Report an error if we get an error reply. Resize
8651 *BUF using xrealloc if necessary to hold the result, and update
8655 remote_send (char **buf
,
8659 getpkt (buf
, sizeof_buf
, 0);
8661 if ((*buf
)[0] == 'E')
8662 error (_("Remote failure reply: %s"), *buf
);
8665 /* Return a string representing an escaped version of BUF, of len N.
8666 E.g. \n is converted to \\n, \t to \\t, etc. */
8669 escape_buffer (const char *buf
, int n
)
8673 stb
.putstrn (buf
, n
, '\\');
8674 return std::move (stb
.string ());
8677 /* Display a null-terminated packet on stdout, for debugging, using C
8681 print_packet (const char *buf
)
8683 puts_filtered ("\"");
8684 fputstr_filtered (buf
, '"', gdb_stdout
);
8685 puts_filtered ("\"");
8689 putpkt (const char *buf
)
8691 return putpkt_binary (buf
, strlen (buf
));
8694 /* Send a packet to the remote machine, with error checking. The data
8695 of the packet is in BUF. The string in BUF can be at most
8696 get_remote_packet_size () - 5 to account for the $, # and checksum,
8697 and for a possible /0 if we are debugging (remote_debug) and want
8698 to print the sent packet as a string. */
8701 putpkt_binary (const char *buf
, int cnt
)
8703 struct remote_state
*rs
= get_remote_state ();
8705 unsigned char csum
= 0;
8706 char *buf2
= (char *) xmalloc (cnt
+ 6);
8707 struct cleanup
*old_chain
= make_cleanup (xfree
, buf2
);
8713 /* Catch cases like trying to read memory or listing threads while
8714 we're waiting for a stop reply. The remote server wouldn't be
8715 ready to handle this request, so we'd hang and timeout. We don't
8716 have to worry about this in synchronous mode, because in that
8717 case it's not possible to issue a command while the target is
8718 running. This is not a problem in non-stop mode, because in that
8719 case, the stub is always ready to process serial input. */
8720 if (!target_is_non_stop_p ()
8721 && target_is_async_p ()
8722 && rs
->waiting_for_stop_reply
)
8724 error (_("Cannot execute this command while the target is running.\n"
8725 "Use the \"interrupt\" command to stop the target\n"
8726 "and then try again."));
8729 /* We're sending out a new packet. Make sure we don't look at a
8730 stale cached response. */
8731 rs
->cached_wait_status
= 0;
8733 /* Copy the packet into buffer BUF2, encapsulating it
8734 and giving it a checksum. */
8739 for (i
= 0; i
< cnt
; i
++)
8745 *p
++ = tohex ((csum
>> 4) & 0xf);
8746 *p
++ = tohex (csum
& 0xf);
8748 /* Send it over and over until we get a positive ack. */
8752 int started_error_output
= 0;
8758 int len
= (int) (p
- buf2
);
8761 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
8763 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
8765 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
8767 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
8768 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
8771 fprintf_unfiltered (gdb_stdlog
, "...");
8773 gdb_flush (gdb_stdlog
);
8775 remote_serial_write (buf2
, p
- buf2
);
8777 /* If this is a no acks version of the remote protocol, send the
8778 packet and move on. */
8782 /* Read until either a timeout occurs (-2) or '+' is read.
8783 Handle any notification that arrives in the mean time. */
8786 ch
= readchar (remote_timeout
);
8794 case SERIAL_TIMEOUT
:
8797 if (started_error_output
)
8799 putchar_unfiltered ('\n');
8800 started_error_output
= 0;
8809 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
8810 do_cleanups (old_chain
);
8814 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
8816 case SERIAL_TIMEOUT
:
8820 do_cleanups (old_chain
);
8823 break; /* Retransmit buffer. */
8827 fprintf_unfiltered (gdb_stdlog
,
8828 "Packet instead of Ack, ignoring it\n");
8829 /* It's probably an old response sent because an ACK
8830 was lost. Gobble up the packet and ack it so it
8831 doesn't get retransmitted when we resend this
8834 remote_serial_write ("+", 1);
8835 continue; /* Now, go look for +. */
8842 /* If we got a notification, handle it, and go back to looking
8844 /* We've found the start of a notification. Now
8845 collect the data. */
8846 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
8851 std::string str
= escape_buffer (rs
->buf
, val
);
8853 fprintf_unfiltered (gdb_stdlog
,
8854 " Notification received: %s\n",
8857 handle_notification (rs
->notif_state
, rs
->buf
);
8858 /* We're in sync now, rewait for the ack. */
8865 if (!started_error_output
)
8867 started_error_output
= 1;
8868 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8870 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8871 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
8880 if (!started_error_output
)
8882 started_error_output
= 1;
8883 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8885 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8889 break; /* Here to retransmit. */
8893 /* This is wrong. If doing a long backtrace, the user should be
8894 able to get out next time we call QUIT, without anything as
8895 violent as interrupt_query. If we want to provide a way out of
8896 here without getting to the next QUIT, it should be based on
8897 hitting ^C twice as in remote_wait. */
8906 do_cleanups (old_chain
);
8910 /* Come here after finding the start of a frame when we expected an
8911 ack. Do our best to discard the rest of this packet. */
8920 c
= readchar (remote_timeout
);
8923 case SERIAL_TIMEOUT
:
8924 /* Nothing we can do. */
8927 /* Discard the two bytes of checksum and stop. */
8928 c
= readchar (remote_timeout
);
8930 c
= readchar (remote_timeout
);
8933 case '*': /* Run length encoding. */
8934 /* Discard the repeat count. */
8935 c
= readchar (remote_timeout
);
8940 /* A regular character. */
8946 /* Come here after finding the start of the frame. Collect the rest
8947 into *BUF, verifying the checksum, length, and handling run-length
8948 compression. NUL terminate the buffer. If there is not enough room,
8949 expand *BUF using xrealloc.
8951 Returns -1 on error, number of characters in buffer (ignoring the
8952 trailing NULL) on success. (could be extended to return one of the
8953 SERIAL status indications). */
8956 read_frame (char **buf_p
,
8963 struct remote_state
*rs
= get_remote_state ();
8970 c
= readchar (remote_timeout
);
8973 case SERIAL_TIMEOUT
:
8975 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
8979 fputs_filtered ("Saw new packet start in middle of old one\n",
8981 return -1; /* Start a new packet, count retries. */
8984 unsigned char pktcsum
;
8990 check_0
= readchar (remote_timeout
);
8992 check_1
= readchar (remote_timeout
);
8994 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
8997 fputs_filtered ("Timeout in checksum, retrying\n",
9001 else if (check_0
< 0 || check_1
< 0)
9004 fputs_filtered ("Communication error in checksum\n",
9009 /* Don't recompute the checksum; with no ack packets we
9010 don't have any way to indicate a packet retransmission
9015 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9016 if (csum
== pktcsum
)
9021 std::string str
= escape_buffer (buf
, bc
);
9023 fprintf_unfiltered (gdb_stdlog
,
9024 "Bad checksum, sentsum=0x%x, "
9025 "csum=0x%x, buf=%s\n",
9026 pktcsum
, csum
, str
.c_str ());
9028 /* Number of characters in buffer ignoring trailing
9032 case '*': /* Run length encoding. */
9037 c
= readchar (remote_timeout
);
9039 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9041 /* The character before ``*'' is repeated. */
9043 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9045 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
9047 /* Make some more room in the buffer. */
9048 *sizeof_buf
+= repeat
;
9049 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9053 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9059 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9063 if (bc
>= *sizeof_buf
- 1)
9065 /* Make some more room in the buffer. */
9067 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9078 /* Read a packet from the remote machine, with error checking, and
9079 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9080 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9081 rather than timing out; this is used (in synchronous mode) to wait
9082 for a target that is is executing user code to stop. */
9083 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9084 don't have to change all the calls to getpkt to deal with the
9085 return value, because at the moment I don't know what the right
9086 thing to do it for those. */
9092 getpkt_sane (buf
, sizeof_buf
, forever
);
9096 /* Read a packet from the remote machine, with error checking, and
9097 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9098 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9099 rather than timing out; this is used (in synchronous mode) to wait
9100 for a target that is is executing user code to stop. If FOREVER ==
9101 0, this function is allowed to time out gracefully and return an
9102 indication of this to the caller. Otherwise return the number of
9103 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9104 enough reason to return to the caller. *IS_NOTIF is an output
9105 boolean that indicates whether *BUF holds a notification or not
9106 (a regular packet). */
9109 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
9110 int expecting_notif
, int *is_notif
)
9112 struct remote_state
*rs
= get_remote_state ();
9118 /* We're reading a new response. Make sure we don't look at a
9119 previously cached response. */
9120 rs
->cached_wait_status
= 0;
9122 strcpy (*buf
, "timeout");
9125 timeout
= watchdog
> 0 ? watchdog
: -1;
9126 else if (expecting_notif
)
9127 timeout
= 0; /* There should already be a char in the buffer. If
9130 timeout
= remote_timeout
;
9134 /* Process any number of notifications, and then return when
9138 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9140 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9142 /* This can loop forever if the remote side sends us
9143 characters continuously, but if it pauses, we'll get
9144 SERIAL_TIMEOUT from readchar because of timeout. Then
9145 we'll count that as a retry.
9147 Note that even when forever is set, we will only wait
9148 forever prior to the start of a packet. After that, we
9149 expect characters to arrive at a brisk pace. They should
9150 show up within remote_timeout intervals. */
9152 c
= readchar (timeout
);
9153 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9155 if (c
== SERIAL_TIMEOUT
)
9157 if (expecting_notif
)
9158 return -1; /* Don't complain, it's normal to not get
9159 anything in this case. */
9161 if (forever
) /* Watchdog went off? Kill the target. */
9163 remote_unpush_target ();
9164 throw_error (TARGET_CLOSE_ERROR
,
9165 _("Watchdog timeout has expired. "
9166 "Target detached."));
9169 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9173 /* We've found the start of a packet or notification.
9174 Now collect the data. */
9175 val
= read_frame (buf
, sizeof_buf
);
9180 remote_serial_write ("-", 1);
9183 if (tries
> MAX_TRIES
)
9185 /* We have tried hard enough, and just can't receive the
9186 packet/notification. Give up. */
9187 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9189 /* Skip the ack char if we're in no-ack mode. */
9190 if (!rs
->noack_mode
)
9191 remote_serial_write ("+", 1);
9195 /* If we got an ordinary packet, return that to our caller. */
9201 = escape_buffer (*buf
,
9202 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9204 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9207 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
9209 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
9210 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
9213 fprintf_unfiltered (gdb_stdlog
, "\n");
9216 /* Skip the ack char if we're in no-ack mode. */
9217 if (!rs
->noack_mode
)
9218 remote_serial_write ("+", 1);
9219 if (is_notif
!= NULL
)
9224 /* If we got a notification, handle it, and go back to looking
9228 gdb_assert (c
== '%');
9232 std::string str
= escape_buffer (*buf
, val
);
9234 fprintf_unfiltered (gdb_stdlog
,
9235 " Notification received: %s\n",
9238 if (is_notif
!= NULL
)
9241 handle_notification (rs
->notif_state
, *buf
);
9243 /* Notifications require no acknowledgement. */
9245 if (expecting_notif
)
9252 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
9254 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
9258 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
9261 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
9265 /* Check whether EVENT is a fork event for the process specified
9266 by the pid passed in DATA, and if it is, kill the fork child. */
9269 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
9270 QUEUE_ITER (stop_reply_p
) *iter
,
9274 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
9275 int parent_pid
= *(int *) param
->input
;
9277 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
9279 struct remote_state
*rs
= get_remote_state ();
9280 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
9283 res
= remote_vkill (child_pid
, rs
);
9285 error (_("Can't kill fork child process %d"), child_pid
);
9291 /* Kill any new fork children of process PID that haven't been
9292 processed by follow_fork. */
9295 kill_new_fork_children (int pid
, struct remote_state
*rs
)
9297 struct thread_info
*thread
;
9298 struct notif_client
*notif
= ¬if_client_stop
;
9299 struct queue_iter_param param
;
9301 /* Kill the fork child threads of any threads in process PID
9302 that are stopped at a fork event. */
9303 ALL_NON_EXITED_THREADS (thread
)
9305 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9307 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9309 struct remote_state
*rs
= get_remote_state ();
9310 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
9313 res
= remote_vkill (child_pid
, rs
);
9315 error (_("Can't kill fork child process %d"), child_pid
);
9319 /* Check for any pending fork events (not reported or processed yet)
9320 in process PID and kill those fork child threads as well. */
9321 remote_notif_get_pending_events (notif
);
9323 param
.output
= NULL
;
9324 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
9325 kill_child_of_pending_fork
, ¶m
);
9329 /* Target hook to kill the current inferior. */
9332 remote_kill (struct target_ops
*ops
)
9335 int pid
= ptid_get_pid (inferior_ptid
);
9336 struct remote_state
*rs
= get_remote_state ();
9338 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9340 /* If we're stopped while forking and we haven't followed yet,
9341 kill the child task. We need to do this before killing the
9342 parent task because if this is a vfork then the parent will
9344 kill_new_fork_children (pid
, rs
);
9346 res
= remote_vkill (pid
, rs
);
9349 target_mourn_inferior (inferior_ptid
);
9354 /* If we are in 'target remote' mode and we are killing the only
9355 inferior, then we will tell gdbserver to exit and unpush the
9357 if (res
== -1 && !remote_multi_process_p (rs
)
9358 && number_of_live_inferiors () == 1)
9362 /* We've killed the remote end, we get to mourn it. If we are
9363 not in extended mode, mourning the inferior also unpushes
9364 remote_ops from the target stack, which closes the remote
9366 target_mourn_inferior (inferior_ptid
);
9371 error (_("Can't kill process"));
9374 /* Send a kill request to the target using the 'vKill' packet. */
9377 remote_vkill (int pid
, struct remote_state
*rs
)
9379 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9382 /* Tell the remote target to detach. */
9383 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
9385 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9387 switch (packet_ok (rs
->buf
,
9388 &remote_protocol_packets
[PACKET_vKill
]))
9394 case PACKET_UNKNOWN
:
9397 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9401 /* Send a kill request to the target using the 'k' packet. */
9404 remote_kill_k (void)
9406 /* Catch errors so the user can quit from gdb even when we
9407 aren't on speaking terms with the remote system. */
9412 CATCH (ex
, RETURN_MASK_ERROR
)
9414 if (ex
.error
== TARGET_CLOSE_ERROR
)
9416 /* If we got an (EOF) error that caused the target
9417 to go away, then we're done, that's what we wanted.
9418 "k" is susceptible to cause a premature EOF, given
9419 that the remote server isn't actually required to
9420 reply to "k", and it can happen that it doesn't
9421 even get to reply ACK to the "k". */
9425 /* Otherwise, something went wrong. We didn't actually kill
9426 the target. Just propagate the exception, and let the
9427 user or higher layers decide what to do. */
9428 throw_exception (ex
);
9434 remote_mourn (struct target_ops
*target
)
9436 struct remote_state
*rs
= get_remote_state ();
9438 /* In 'target remote' mode with one inferior, we close the connection. */
9439 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9441 unpush_target (target
);
9443 /* remote_close takes care of doing most of the clean up. */
9444 generic_mourn_inferior ();
9448 /* In case we got here due to an error, but we're going to stay
9450 rs
->waiting_for_stop_reply
= 0;
9452 /* If the current general thread belonged to the process we just
9453 detached from or has exited, the remote side current general
9454 thread becomes undefined. Considering a case like this:
9456 - We just got here due to a detach.
9457 - The process that we're detaching from happens to immediately
9458 report a global breakpoint being hit in non-stop mode, in the
9459 same thread we had selected before.
9460 - GDB attaches to this process again.
9461 - This event happens to be the next event we handle.
9463 GDB would consider that the current general thread didn't need to
9464 be set on the stub side (with Hg), since for all it knew,
9465 GENERAL_THREAD hadn't changed.
9467 Notice that although in all-stop mode, the remote server always
9468 sets the current thread to the thread reporting the stop event,
9469 that doesn't happen in non-stop mode; in non-stop, the stub *must
9470 not* change the current thread when reporting a breakpoint hit,
9471 due to the decoupling of event reporting and event handling.
9473 To keep things simple, we always invalidate our notion of the
9475 record_currthread (rs
, minus_one_ptid
);
9477 /* Call common code to mark the inferior as not running. */
9478 generic_mourn_inferior ();
9480 if (!have_inferiors ())
9482 if (!remote_multi_process_p (rs
))
9484 /* Check whether the target is running now - some remote stubs
9485 automatically restart after kill. */
9487 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9489 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9491 /* Assume that the target has been restarted. Set
9492 inferior_ptid so that bits of core GDB realizes
9493 there's something here, e.g., so that the user can
9494 say "kill" again. */
9495 inferior_ptid
= magic_null_ptid
;
9502 extended_remote_supports_disable_randomization (struct target_ops
*self
)
9504 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9508 extended_remote_disable_randomization (int val
)
9510 struct remote_state
*rs
= get_remote_state ();
9513 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
9516 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9518 error (_("Target does not support QDisableRandomization."));
9519 if (strcmp (reply
, "OK") != 0)
9520 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9524 extended_remote_run (const std::string
&args
)
9526 struct remote_state
*rs
= get_remote_state ();
9528 const char *remote_exec_file
= get_remote_exec_file ();
9530 /* If the user has disabled vRun support, or we have detected that
9531 support is not available, do not try it. */
9532 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9535 strcpy (rs
->buf
, "vRun;");
9536 len
= strlen (rs
->buf
);
9538 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9539 error (_("Remote file name too long for run packet"));
9540 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
9541 strlen (remote_exec_file
));
9545 struct cleanup
*back_to
;
9549 argv
= gdb_buildargv (args
.c_str ());
9550 back_to
= make_cleanup_freeargv (argv
);
9551 for (i
= 0; argv
[i
] != NULL
; i
++)
9553 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9554 error (_("Argument list too long for run packet"));
9555 rs
->buf
[len
++] = ';';
9556 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
9559 do_cleanups (back_to
);
9562 rs
->buf
[len
++] = '\0';
9565 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9567 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9570 /* We have a wait response. All is well. */
9572 case PACKET_UNKNOWN
:
9575 if (remote_exec_file
[0] == '\0')
9576 error (_("Running the default executable on the remote target failed; "
9577 "try \"set remote exec-file\"?"));
9579 error (_("Running \"%s\" on the remote target failed"),
9582 gdb_assert_not_reached (_("bad switch"));
9586 /* In the extended protocol we want to be able to do things like
9587 "run" and have them basically work as expected. So we need
9588 a special create_inferior function. We support changing the
9589 executable file and the command line arguments, but not the
9593 extended_remote_create_inferior (struct target_ops
*ops
,
9594 const char *exec_file
,
9595 const std::string
&args
,
9596 char **env
, int from_tty
)
9600 struct remote_state
*rs
= get_remote_state ();
9601 const char *remote_exec_file
= get_remote_exec_file ();
9603 /* If running asynchronously, register the target file descriptor
9604 with the event loop. */
9605 if (target_can_async_p ())
9608 /* Disable address space randomization if requested (and supported). */
9609 if (extended_remote_supports_disable_randomization (ops
))
9610 extended_remote_disable_randomization (disable_randomization
);
9612 /* If startup-with-shell is on, we inform gdbserver to start the
9613 remote inferior using a shell. */
9614 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
9616 xsnprintf (rs
->buf
, get_remote_packet_size (),
9617 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
9619 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9620 if (strcmp (rs
->buf
, "OK") != 0)
9622 Remote replied unexpectedly while setting startup-with-shell: %s"),
9626 /* Now restart the remote server. */
9627 run_worked
= extended_remote_run (args
) != -1;
9630 /* vRun was not supported. Fail if we need it to do what the
9632 if (remote_exec_file
[0])
9633 error (_("Remote target does not support \"set remote exec-file\""));
9635 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9637 /* Fall back to "R". */
9638 extended_remote_restart ();
9641 if (!have_inferiors ())
9643 /* Clean up from the last time we ran, before we mark the target
9644 running again. This will mark breakpoints uninserted, and
9645 get_offsets may insert breakpoints. */
9646 init_thread_list ();
9647 init_wait_for_inferior ();
9650 /* vRun's success return is a stop reply. */
9651 stop_reply
= run_worked
? rs
->buf
: NULL
;
9652 add_current_inferior_and_thread (stop_reply
);
9654 /* Get updated offsets, if the stub uses qOffsets. */
9659 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9660 the list of conditions (in agent expression bytecode format), if any, the
9661 target needs to evaluate. The output is placed into the packet buffer
9662 started from BUF and ended at BUF_END. */
9665 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
9666 struct bp_target_info
*bp_tgt
, char *buf
,
9669 if (bp_tgt
->conditions
.empty ())
9672 buf
+= strlen (buf
);
9673 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
9676 /* Send conditions to the target. */
9677 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
9679 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
9680 buf
+= strlen (buf
);
9681 for (int i
= 0; i
< aexpr
->len
; ++i
)
9682 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9689 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
9690 struct bp_target_info
*bp_tgt
, char *buf
)
9692 if (bp_tgt
->tcommands
.empty ())
9695 buf
+= strlen (buf
);
9697 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
9698 buf
+= strlen (buf
);
9700 /* Concatenate all the agent expressions that are commands into the
9702 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
9704 sprintf (buf
, "X%x,", aexpr
->len
);
9705 buf
+= strlen (buf
);
9706 for (int i
= 0; i
< aexpr
->len
; ++i
)
9707 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9712 /* Insert a breakpoint. On targets that have software breakpoint
9713 support, we ask the remote target to do the work; on targets
9714 which don't, we insert a traditional memory breakpoint. */
9717 remote_insert_breakpoint (struct target_ops
*ops
,
9718 struct gdbarch
*gdbarch
,
9719 struct bp_target_info
*bp_tgt
)
9721 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9722 If it succeeds, then set the support to PACKET_ENABLE. If it
9723 fails, and the user has explicitly requested the Z support then
9724 report an error, otherwise, mark it disabled and go on. */
9726 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9728 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9729 struct remote_state
*rs
;
9733 /* Make sure the remote is pointing at the right process, if
9735 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9736 set_general_process ();
9738 rs
= get_remote_state ();
9740 endbuf
= rs
->buf
+ get_remote_packet_size ();
9745 addr
= (ULONGEST
) remote_address_masked (addr
);
9746 p
+= hexnumstr (p
, addr
);
9747 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9749 if (remote_supports_cond_breakpoints (ops
))
9750 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
9752 if (remote_can_run_breakpoint_commands (ops
))
9753 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
9756 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9758 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
9764 case PACKET_UNKNOWN
:
9769 /* If this breakpoint has target-side commands but this stub doesn't
9770 support Z0 packets, throw error. */
9771 if (!bp_tgt
->tcommands
.empty ())
9772 throw_error (NOT_SUPPORTED_ERROR
, _("\
9773 Target doesn't support breakpoints that have target side commands."));
9775 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
9779 remote_remove_breakpoint (struct target_ops
*ops
,
9780 struct gdbarch
*gdbarch
,
9781 struct bp_target_info
*bp_tgt
,
9782 enum remove_bp_reason reason
)
9784 CORE_ADDR addr
= bp_tgt
->placed_address
;
9785 struct remote_state
*rs
= get_remote_state ();
9787 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9790 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9792 /* Make sure the remote is pointing at the right process, if
9794 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9795 set_general_process ();
9801 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
9802 p
+= hexnumstr (p
, addr
);
9803 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9806 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9808 return (rs
->buf
[0] == 'E');
9811 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
, reason
);
9814 static enum Z_packet_type
9815 watchpoint_to_Z_packet (int type
)
9820 return Z_PACKET_WRITE_WP
;
9823 return Z_PACKET_READ_WP
;
9826 return Z_PACKET_ACCESS_WP
;
9829 internal_error (__FILE__
, __LINE__
,
9830 _("hw_bp_to_z: bad watchpoint type %d"), type
);
9835 remote_insert_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9836 enum target_hw_bp_type type
, struct expression
*cond
)
9838 struct remote_state
*rs
= get_remote_state ();
9839 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9841 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9843 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9846 /* Make sure the remote is pointing at the right process, if
9848 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9849 set_general_process ();
9851 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
9852 p
= strchr (rs
->buf
, '\0');
9853 addr
= remote_address_masked (addr
);
9854 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9855 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9858 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9860 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9864 case PACKET_UNKNOWN
:
9869 internal_error (__FILE__
, __LINE__
,
9870 _("remote_insert_watchpoint: reached end of function"));
9874 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
9875 CORE_ADDR start
, int length
)
9877 CORE_ADDR diff
= remote_address_masked (addr
- start
);
9879 return diff
< length
;
9884 remote_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9885 enum target_hw_bp_type type
, struct expression
*cond
)
9887 struct remote_state
*rs
= get_remote_state ();
9888 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9890 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9892 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9895 /* Make sure the remote is pointing at the right process, if
9897 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9898 set_general_process ();
9900 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
9901 p
= strchr (rs
->buf
, '\0');
9902 addr
= remote_address_masked (addr
);
9903 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9904 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9906 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9908 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9911 case PACKET_UNKNOWN
:
9916 internal_error (__FILE__
, __LINE__
,
9917 _("remote_remove_watchpoint: reached end of function"));
9921 int remote_hw_watchpoint_limit
= -1;
9922 int remote_hw_watchpoint_length_limit
= -1;
9923 int remote_hw_breakpoint_limit
= -1;
9926 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
9927 CORE_ADDR addr
, int len
)
9929 if (remote_hw_watchpoint_length_limit
== 0)
9931 else if (remote_hw_watchpoint_length_limit
< 0)
9933 else if (len
<= remote_hw_watchpoint_length_limit
)
9940 remote_check_watch_resources (struct target_ops
*self
,
9941 enum bptype type
, int cnt
, int ot
)
9943 if (type
== bp_hardware_breakpoint
)
9945 if (remote_hw_breakpoint_limit
== 0)
9947 else if (remote_hw_breakpoint_limit
< 0)
9949 else if (cnt
<= remote_hw_breakpoint_limit
)
9954 if (remote_hw_watchpoint_limit
== 0)
9956 else if (remote_hw_watchpoint_limit
< 0)
9960 else if (cnt
<= remote_hw_watchpoint_limit
)
9966 /* The to_stopped_by_sw_breakpoint method of target remote. */
9969 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9971 struct thread_info
*thread
= inferior_thread ();
9973 return (thread
->priv
!= NULL
9974 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
9977 /* The to_supports_stopped_by_sw_breakpoint method of target
9981 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9983 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
9986 /* The to_stopped_by_hw_breakpoint method of target remote. */
9989 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
9991 struct thread_info
*thread
= inferior_thread ();
9993 return (thread
->priv
!= NULL
9994 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
9997 /* The to_supports_stopped_by_hw_breakpoint method of target
10001 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10003 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10007 remote_stopped_by_watchpoint (struct target_ops
*ops
)
10009 struct thread_info
*thread
= inferior_thread ();
10011 return (thread
->priv
!= NULL
10012 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
);
10016 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
10018 struct thread_info
*thread
= inferior_thread ();
10020 if (thread
->priv
!= NULL
10021 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
10023 *addr_p
= thread
->priv
->watch_data_address
;
10032 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10033 struct bp_target_info
*bp_tgt
)
10035 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10036 struct remote_state
*rs
;
10040 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10043 /* Make sure the remote is pointing at the right process, if
10045 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10046 set_general_process ();
10048 rs
= get_remote_state ();
10050 endbuf
= rs
->buf
+ get_remote_packet_size ();
10056 addr
= remote_address_masked (addr
);
10057 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10058 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10060 if (remote_supports_cond_breakpoints (self
))
10061 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10063 if (remote_can_run_breakpoint_commands (self
))
10064 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10067 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10069 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10072 if (rs
->buf
[1] == '.')
10074 message
= strchr (rs
->buf
+ 2, '.');
10076 error (_("Remote failure reply: %s"), message
+ 1);
10079 case PACKET_UNKNOWN
:
10084 internal_error (__FILE__
, __LINE__
,
10085 _("remote_insert_hw_breakpoint: reached end of function"));
10090 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10091 struct bp_target_info
*bp_tgt
)
10094 struct remote_state
*rs
= get_remote_state ();
10096 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
10098 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10101 /* Make sure the remote is pointing at the right process, if
10103 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10104 set_general_process ();
10110 addr
= remote_address_masked (bp_tgt
->placed_address
);
10111 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10112 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10115 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10117 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10120 case PACKET_UNKNOWN
:
10125 internal_error (__FILE__
, __LINE__
,
10126 _("remote_remove_hw_breakpoint: reached end of function"));
10129 /* Verify memory using the "qCRC:" request. */
10132 remote_verify_memory (struct target_ops
*ops
,
10133 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10135 struct remote_state
*rs
= get_remote_state ();
10136 unsigned long host_crc
, target_crc
;
10139 /* It doesn't make sense to use qCRC if the remote target is
10140 connected but not running. */
10141 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10143 enum packet_result result
;
10145 /* Make sure the remote is pointing at the right process. */
10146 set_general_process ();
10148 /* FIXME: assumes lma can fit into long. */
10149 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
10150 (long) lma
, (long) size
);
10153 /* Be clever; compute the host_crc before waiting for target
10155 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10157 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10159 result
= packet_ok (rs
->buf
,
10160 &remote_protocol_packets
[PACKET_qCRC
]);
10161 if (result
== PACKET_ERROR
)
10163 else if (result
== PACKET_OK
)
10165 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10166 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10168 return (host_crc
== target_crc
);
10172 return simple_verify_memory (ops
, data
, lma
, size
);
10175 /* compare-sections command
10177 With no arguments, compares each loadable section in the exec bfd
10178 with the same memory range on the target, and reports mismatches.
10179 Useful for verifying the image on the target against the exec file. */
10182 compare_sections_command (char *args
, int from_tty
)
10185 struct cleanup
*old_chain
;
10186 gdb_byte
*sectdata
;
10187 const char *sectname
;
10188 bfd_size_type size
;
10191 int mismatched
= 0;
10196 error (_("command cannot be used without an exec file"));
10198 /* Make sure the remote is pointing at the right process. */
10199 set_general_process ();
10201 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10207 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10209 if (!(s
->flags
& SEC_LOAD
))
10210 continue; /* Skip non-loadable section. */
10212 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10213 continue; /* Skip writeable sections */
10215 size
= bfd_get_section_size (s
);
10217 continue; /* Skip zero-length section. */
10219 sectname
= bfd_get_section_name (exec_bfd
, s
);
10220 if (args
&& strcmp (args
, sectname
) != 0)
10221 continue; /* Not the section selected by user. */
10223 matched
= 1; /* Do this section. */
10226 sectdata
= (gdb_byte
*) xmalloc (size
);
10227 old_chain
= make_cleanup (xfree
, sectdata
);
10228 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
10230 res
= target_verify_memory (sectdata
, lma
, size
);
10233 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10234 paddress (target_gdbarch (), lma
),
10235 paddress (target_gdbarch (), lma
+ size
));
10237 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10238 paddress (target_gdbarch (), lma
),
10239 paddress (target_gdbarch (), lma
+ size
));
10241 printf_filtered ("matched.\n");
10244 printf_filtered ("MIS-MATCHED!\n");
10248 do_cleanups (old_chain
);
10250 if (mismatched
> 0)
10251 warning (_("One or more sections of the target image does not match\n\
10252 the loaded file\n"));
10253 if (args
&& !matched
)
10254 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10257 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10258 into remote target. The number of bytes written to the remote
10259 target is returned, or -1 for error. */
10261 static enum target_xfer_status
10262 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
10263 const char *annex
, const gdb_byte
*writebuf
,
10264 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
10265 struct packet_config
*packet
)
10269 struct remote_state
*rs
= get_remote_state ();
10270 int max_size
= get_memory_write_packet_size ();
10272 if (packet
->support
== PACKET_DISABLE
)
10273 return TARGET_XFER_E_IO
;
10275 /* Insert header. */
10276 i
= snprintf (rs
->buf
, max_size
,
10277 "qXfer:%s:write:%s:%s:",
10278 object_name
, annex
? annex
: "",
10279 phex_nz (offset
, sizeof offset
));
10280 max_size
-= (i
+ 1);
10282 /* Escape as much data as fits into rs->buf. */
10283 buf_len
= remote_escape_output
10284 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
10286 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
10287 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10288 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10289 return TARGET_XFER_E_IO
;
10291 unpack_varlen_hex (rs
->buf
, &n
);
10294 return TARGET_XFER_OK
;
10297 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10298 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10299 number of bytes read is returned, or 0 for EOF, or -1 for error.
10300 The number of bytes read may be less than LEN without indicating an
10301 EOF. PACKET is checked and updated to indicate whether the remote
10302 target supports this object. */
10304 static enum target_xfer_status
10305 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
10307 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
10308 ULONGEST
*xfered_len
,
10309 struct packet_config
*packet
)
10311 struct remote_state
*rs
= get_remote_state ();
10312 LONGEST i
, n
, packet_len
;
10314 if (packet
->support
== PACKET_DISABLE
)
10315 return TARGET_XFER_E_IO
;
10317 /* Check whether we've cached an end-of-object packet that matches
10319 if (rs
->finished_object
)
10321 if (strcmp (object_name
, rs
->finished_object
) == 0
10322 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10323 && offset
== rs
->finished_offset
)
10324 return TARGET_XFER_EOF
;
10327 /* Otherwise, we're now reading something different. Discard
10329 xfree (rs
->finished_object
);
10330 xfree (rs
->finished_annex
);
10331 rs
->finished_object
= NULL
;
10332 rs
->finished_annex
= NULL
;
10335 /* Request only enough to fit in a single packet. The actual data
10336 may not, since we don't know how much of it will need to be escaped;
10337 the target is free to respond with slightly less data. We subtract
10338 five to account for the response type and the protocol frame. */
10339 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10340 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10341 object_name
, annex
? annex
: "",
10342 phex_nz (offset
, sizeof offset
),
10343 phex_nz (n
, sizeof n
));
10344 i
= putpkt (rs
->buf
);
10346 return TARGET_XFER_E_IO
;
10349 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10350 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10351 return TARGET_XFER_E_IO
;
10353 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10354 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
10356 /* 'm' means there is (or at least might be) more data after this
10357 batch. That does not make sense unless there's at least one byte
10358 of data in this reply. */
10359 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10360 error (_("Remote qXfer reply contained no data."));
10362 /* Got some data. */
10363 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
10364 packet_len
- 1, readbuf
, n
);
10366 /* 'l' is an EOF marker, possibly including a final block of data,
10367 or possibly empty. If we have the final block of a non-empty
10368 object, record this fact to bypass a subsequent partial read. */
10369 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10371 rs
->finished_object
= xstrdup (object_name
);
10372 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10373 rs
->finished_offset
= offset
+ i
;
10377 return TARGET_XFER_EOF
;
10381 return TARGET_XFER_OK
;
10385 static enum target_xfer_status
10386 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
10387 const char *annex
, gdb_byte
*readbuf
,
10388 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10389 ULONGEST
*xfered_len
)
10391 struct remote_state
*rs
;
10395 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10397 set_remote_traceframe ();
10398 set_general_thread (inferior_ptid
);
10400 rs
= get_remote_state ();
10402 /* Handle memory using the standard memory routines. */
10403 if (object
== TARGET_OBJECT_MEMORY
)
10405 /* If the remote target is connected but not running, we should
10406 pass this request down to a lower stratum (e.g. the executable
10408 if (!target_has_execution
)
10409 return TARGET_XFER_EOF
;
10411 if (writebuf
!= NULL
)
10412 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10415 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
10419 /* Handle SPU memory using qxfer packets. */
10420 if (object
== TARGET_OBJECT_SPU
)
10423 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
10424 xfered_len
, &remote_protocol_packets
10425 [PACKET_qXfer_spu_read
]);
10427 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
10428 xfered_len
, &remote_protocol_packets
10429 [PACKET_qXfer_spu_write
]);
10432 /* Handle extra signal info using qxfer packets. */
10433 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10436 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
10437 xfered_len
, &remote_protocol_packets
10438 [PACKET_qXfer_siginfo_read
]);
10440 return remote_write_qxfer (ops
, "siginfo", annex
,
10441 writebuf
, offset
, len
, xfered_len
,
10442 &remote_protocol_packets
10443 [PACKET_qXfer_siginfo_write
]);
10446 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10449 return remote_read_qxfer (ops
, "statictrace", annex
,
10450 readbuf
, offset
, len
, xfered_len
,
10451 &remote_protocol_packets
10452 [PACKET_qXfer_statictrace_read
]);
10454 return TARGET_XFER_E_IO
;
10457 /* Only handle flash writes. */
10458 if (writebuf
!= NULL
)
10462 case TARGET_OBJECT_FLASH
:
10463 return remote_flash_write (ops
, offset
, len
, xfered_len
,
10467 return TARGET_XFER_E_IO
;
10471 /* Map pre-existing objects onto letters. DO NOT do this for new
10472 objects!!! Instead specify new query packets. */
10475 case TARGET_OBJECT_AVR
:
10479 case TARGET_OBJECT_AUXV
:
10480 gdb_assert (annex
== NULL
);
10481 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
10483 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10485 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10486 return remote_read_qxfer
10487 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
10488 &remote_protocol_packets
[PACKET_qXfer_features
]);
10490 case TARGET_OBJECT_LIBRARIES
:
10491 return remote_read_qxfer
10492 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10493 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10495 case TARGET_OBJECT_LIBRARIES_SVR4
:
10496 return remote_read_qxfer
10497 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10498 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10500 case TARGET_OBJECT_MEMORY_MAP
:
10501 gdb_assert (annex
== NULL
);
10502 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
10504 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10506 case TARGET_OBJECT_OSDATA
:
10507 /* Should only get here if we're connected. */
10508 gdb_assert (rs
->remote_desc
);
10509 return remote_read_qxfer
10510 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10511 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10513 case TARGET_OBJECT_THREADS
:
10514 gdb_assert (annex
== NULL
);
10515 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
10517 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10519 case TARGET_OBJECT_TRACEFRAME_INFO
:
10520 gdb_assert (annex
== NULL
);
10521 return remote_read_qxfer
10522 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10523 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10525 case TARGET_OBJECT_FDPIC
:
10526 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
10528 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10530 case TARGET_OBJECT_OPENVMS_UIB
:
10531 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
10533 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10535 case TARGET_OBJECT_BTRACE
:
10536 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
10538 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10540 case TARGET_OBJECT_BTRACE_CONF
:
10541 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
10543 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10545 case TARGET_OBJECT_EXEC_FILE
:
10546 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
10548 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10551 return TARGET_XFER_E_IO
;
10554 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10555 large enough let the caller deal with it. */
10556 if (len
< get_remote_packet_size ())
10557 return TARGET_XFER_E_IO
;
10558 len
= get_remote_packet_size ();
10560 /* Except for querying the minimum buffer size, target must be open. */
10561 if (!rs
->remote_desc
)
10562 error (_("remote query is only available after target open"));
10564 gdb_assert (annex
!= NULL
);
10565 gdb_assert (readbuf
!= NULL
);
10569 *p2
++ = query_type
;
10571 /* We used one buffer char for the remote protocol q command and
10572 another for the query type. As the remote protocol encapsulation
10573 uses 4 chars plus one extra in case we are debugging
10574 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10577 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10579 /* Bad caller may have sent forbidden characters. */
10580 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10585 gdb_assert (annex
[i
] == '\0');
10587 i
= putpkt (rs
->buf
);
10589 return TARGET_XFER_E_IO
;
10591 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10592 strcpy ((char *) readbuf
, rs
->buf
);
10594 *xfered_len
= strlen ((char *) readbuf
);
10595 return TARGET_XFER_OK
;
10598 /* Implementation of to_get_memory_xfer_limit. */
10601 remote_get_memory_xfer_limit (struct target_ops
*ops
)
10603 return get_memory_write_packet_size ();
10607 remote_search_memory (struct target_ops
* ops
,
10608 CORE_ADDR start_addr
, ULONGEST search_space_len
,
10609 const gdb_byte
*pattern
, ULONGEST pattern_len
,
10610 CORE_ADDR
*found_addrp
)
10612 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
10613 struct remote_state
*rs
= get_remote_state ();
10614 int max_size
= get_memory_write_packet_size ();
10615 struct packet_config
*packet
=
10616 &remote_protocol_packets
[PACKET_qSearch_memory
];
10617 /* Number of packet bytes used to encode the pattern;
10618 this could be more than PATTERN_LEN due to escape characters. */
10619 int escaped_pattern_len
;
10620 /* Amount of pattern that was encodable in the packet. */
10621 int used_pattern_len
;
10624 ULONGEST found_addr
;
10626 /* Don't go to the target if we don't have to.
10627 This is done before checking packet->support to avoid the possibility that
10628 a success for this edge case means the facility works in general. */
10629 if (pattern_len
> search_space_len
)
10631 if (pattern_len
== 0)
10633 *found_addrp
= start_addr
;
10637 /* If we already know the packet isn't supported, fall back to the simple
10638 way of searching memory. */
10640 if (packet_config_support (packet
) == PACKET_DISABLE
)
10642 /* Target doesn't provided special support, fall back and use the
10643 standard support (copy memory and do the search here). */
10644 return simple_search_memory (ops
, start_addr
, search_space_len
,
10645 pattern
, pattern_len
, found_addrp
);
10648 /* Make sure the remote is pointing at the right process. */
10649 set_general_process ();
10651 /* Insert header. */
10652 i
= snprintf (rs
->buf
, max_size
,
10653 "qSearch:memory:%s;%s;",
10654 phex_nz (start_addr
, addr_size
),
10655 phex_nz (search_space_len
, sizeof (search_space_len
)));
10656 max_size
-= (i
+ 1);
10658 /* Escape as much data as fits into rs->buf. */
10659 escaped_pattern_len
=
10660 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
10661 &used_pattern_len
, max_size
);
10663 /* Bail if the pattern is too large. */
10664 if (used_pattern_len
!= pattern_len
)
10665 error (_("Pattern is too large to transmit to remote target."));
10667 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
10668 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10669 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10671 /* The request may not have worked because the command is not
10672 supported. If so, fall back to the simple way. */
10673 if (packet
->support
== PACKET_DISABLE
)
10675 return simple_search_memory (ops
, start_addr
, search_space_len
,
10676 pattern
, pattern_len
, found_addrp
);
10681 if (rs
->buf
[0] == '0')
10683 else if (rs
->buf
[0] == '1')
10686 if (rs
->buf
[1] != ',')
10687 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10688 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
10689 *found_addrp
= found_addr
;
10692 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10698 remote_rcmd (struct target_ops
*self
, const char *command
,
10699 struct ui_file
*outbuf
)
10701 struct remote_state
*rs
= get_remote_state ();
10704 if (!rs
->remote_desc
)
10705 error (_("remote rcmd is only available after target open"));
10707 /* Send a NULL command across as an empty command. */
10708 if (command
== NULL
)
10711 /* The query prefix. */
10712 strcpy (rs
->buf
, "qRcmd,");
10713 p
= strchr (rs
->buf
, '\0');
10715 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
10716 > get_remote_packet_size ())
10717 error (_("\"monitor\" command ``%s'' is too long."), command
);
10719 /* Encode the actual command. */
10720 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
10722 if (putpkt (rs
->buf
) < 0)
10723 error (_("Communication problem with target."));
10725 /* get/display the response */
10730 /* XXX - see also remote_get_noisy_reply(). */
10731 QUIT
; /* Allow user to bail out with ^C. */
10733 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
10735 /* Timeout. Continue to (try to) read responses.
10736 This is better than stopping with an error, assuming the stub
10737 is still executing the (long) monitor command.
10738 If needed, the user can interrupt gdb using C-c, obtaining
10739 an effect similar to stop on timeout. */
10743 if (buf
[0] == '\0')
10744 error (_("Target does not support this command."));
10745 if (buf
[0] == 'O' && buf
[1] != 'K')
10747 remote_console_output (buf
+ 1); /* 'O' message from stub. */
10750 if (strcmp (buf
, "OK") == 0)
10752 if (strlen (buf
) == 3 && buf
[0] == 'E'
10753 && isdigit (buf
[1]) && isdigit (buf
[2]))
10755 error (_("Protocol error with Rcmd"));
10757 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
10759 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
10761 fputc_unfiltered (c
, outbuf
);
10767 static VEC(mem_region_s
) *
10768 remote_memory_map (struct target_ops
*ops
)
10770 VEC(mem_region_s
) *result
= NULL
;
10771 char *text
= target_read_stralloc (¤t_target
,
10772 TARGET_OBJECT_MEMORY_MAP
, NULL
);
10776 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
10778 result
= parse_memory_map (text
);
10779 do_cleanups (back_to
);
10786 packet_command (char *args
, int from_tty
)
10788 struct remote_state
*rs
= get_remote_state ();
10790 if (!rs
->remote_desc
)
10791 error (_("command can only be used with remote target"));
10794 error (_("remote-packet command requires packet text as argument"));
10796 puts_filtered ("sending: ");
10797 print_packet (args
);
10798 puts_filtered ("\n");
10801 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10802 puts_filtered ("received: ");
10803 print_packet (rs
->buf
);
10804 puts_filtered ("\n");
10808 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10810 static void display_thread_info (struct gdb_ext_thread_info
*info
);
10812 static void threadset_test_cmd (char *cmd
, int tty
);
10814 static void threadalive_test (char *cmd
, int tty
);
10816 static void threadlist_test_cmd (char *cmd
, int tty
);
10818 int get_and_display_threadinfo (threadref
*ref
);
10820 static void threadinfo_test_cmd (char *cmd
, int tty
);
10822 static int thread_display_step (threadref
*ref
, void *context
);
10824 static void threadlist_update_test_cmd (char *cmd
, int tty
);
10826 static void init_remote_threadtests (void);
10828 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10831 threadset_test_cmd (char *cmd
, int tty
)
10833 int sample_thread
= SAMPLE_THREAD
;
10835 printf_filtered (_("Remote threadset test\n"));
10836 set_general_thread (sample_thread
);
10841 threadalive_test (char *cmd
, int tty
)
10843 int sample_thread
= SAMPLE_THREAD
;
10844 int pid
= ptid_get_pid (inferior_ptid
);
10845 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
10847 if (remote_thread_alive (ptid
))
10848 printf_filtered ("PASS: Thread alive test\n");
10850 printf_filtered ("FAIL: Thread alive test\n");
10853 void output_threadid (char *title
, threadref
*ref
);
10856 output_threadid (char *title
, threadref
*ref
)
10860 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
10862 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
10866 threadlist_test_cmd (char *cmd
, int tty
)
10869 threadref nextthread
;
10870 int done
, result_count
;
10871 threadref threadlist
[3];
10873 printf_filtered ("Remote Threadlist test\n");
10874 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
10875 &result_count
, &threadlist
[0]))
10876 printf_filtered ("FAIL: threadlist test\n");
10879 threadref
*scan
= threadlist
;
10880 threadref
*limit
= scan
+ result_count
;
10882 while (scan
< limit
)
10883 output_threadid (" thread ", scan
++);
10888 display_thread_info (struct gdb_ext_thread_info
*info
)
10890 output_threadid ("Threadid: ", &info
->threadid
);
10891 printf_filtered ("Name: %s\n ", info
->shortname
);
10892 printf_filtered ("State: %s\n", info
->display
);
10893 printf_filtered ("other: %s\n\n", info
->more_display
);
10897 get_and_display_threadinfo (threadref
*ref
)
10901 struct gdb_ext_thread_info threadinfo
;
10903 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
10904 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
10905 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
10906 display_thread_info (&threadinfo
);
10911 threadinfo_test_cmd (char *cmd
, int tty
)
10913 int athread
= SAMPLE_THREAD
;
10917 int_to_threadref (&thread
, athread
);
10918 printf_filtered ("Remote Threadinfo test\n");
10919 if (!get_and_display_threadinfo (&thread
))
10920 printf_filtered ("FAIL cannot get thread info\n");
10924 thread_display_step (threadref
*ref
, void *context
)
10926 /* output_threadid(" threadstep ",ref); *//* simple test */
10927 return get_and_display_threadinfo (ref
);
10931 threadlist_update_test_cmd (char *cmd
, int tty
)
10933 printf_filtered ("Remote Threadlist update test\n");
10934 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
10938 init_remote_threadtests (void)
10940 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
10941 _("Fetch and print the remote list of "
10942 "thread identifiers, one pkt only"));
10943 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
10944 _("Fetch and display info about one thread"));
10945 add_com ("tset", class_obscure
, threadset_test_cmd
,
10946 _("Test setting to a different thread"));
10947 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
10948 _("Iterate through updating all remote thread info"));
10949 add_com ("talive", class_obscure
, threadalive_test
,
10950 _(" Remote thread alive test "));
10955 /* Convert a thread ID to a string. Returns the string in a static
10958 static const char *
10959 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
10961 static char buf
[64];
10962 struct remote_state
*rs
= get_remote_state ();
10964 if (ptid_equal (ptid
, null_ptid
))
10965 return normal_pid_to_str (ptid
);
10966 else if (ptid_is_pid (ptid
))
10968 /* Printing an inferior target id. */
10970 /* When multi-process extensions are off, there's no way in the
10971 remote protocol to know the remote process id, if there's any
10972 at all. There's one exception --- when we're connected with
10973 target extended-remote, and we manually attached to a process
10974 with "attach PID". We don't record anywhere a flag that
10975 allows us to distinguish that case from the case of
10976 connecting with extended-remote and the stub already being
10977 attached to a process, and reporting yes to qAttached, hence
10978 no smart special casing here. */
10979 if (!remote_multi_process_p (rs
))
10981 xsnprintf (buf
, sizeof buf
, "Remote target");
10985 return normal_pid_to_str (ptid
);
10989 if (ptid_equal (magic_null_ptid
, ptid
))
10990 xsnprintf (buf
, sizeof buf
, "Thread <main>");
10991 else if (remote_multi_process_p (rs
))
10992 if (ptid_get_lwp (ptid
) == 0)
10993 return normal_pid_to_str (ptid
);
10995 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
10996 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
10998 xsnprintf (buf
, sizeof buf
, "Thread %ld",
10999 ptid_get_lwp (ptid
));
11004 /* Get the address of the thread local variable in OBJFILE which is
11005 stored at OFFSET within the thread local storage for thread PTID. */
11008 remote_get_thread_local_address (struct target_ops
*ops
,
11009 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
11011 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11013 struct remote_state
*rs
= get_remote_state ();
11015 char *endp
= rs
->buf
+ get_remote_packet_size ();
11016 enum packet_result result
;
11018 strcpy (p
, "qGetTLSAddr:");
11020 p
= write_ptid (p
, endp
, ptid
);
11022 p
+= hexnumstr (p
, offset
);
11024 p
+= hexnumstr (p
, lm
);
11028 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11029 result
= packet_ok (rs
->buf
,
11030 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11031 if (result
== PACKET_OK
)
11035 unpack_varlen_hex (rs
->buf
, &result
);
11038 else if (result
== PACKET_UNKNOWN
)
11039 throw_error (TLS_GENERIC_ERROR
,
11040 _("Remote target doesn't support qGetTLSAddr packet"));
11042 throw_error (TLS_GENERIC_ERROR
,
11043 _("Remote target failed to process qGetTLSAddr request"));
11046 throw_error (TLS_GENERIC_ERROR
,
11047 _("TLS not supported or disabled on this target"));
11052 /* Provide thread local base, i.e. Thread Information Block address.
11053 Returns 1 if ptid is found and thread_local_base is non zero. */
11056 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
11058 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11060 struct remote_state
*rs
= get_remote_state ();
11062 char *endp
= rs
->buf
+ get_remote_packet_size ();
11063 enum packet_result result
;
11065 strcpy (p
, "qGetTIBAddr:");
11067 p
= write_ptid (p
, endp
, ptid
);
11071 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11072 result
= packet_ok (rs
->buf
,
11073 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11074 if (result
== PACKET_OK
)
11078 unpack_varlen_hex (rs
->buf
, &result
);
11080 *addr
= (CORE_ADDR
) result
;
11083 else if (result
== PACKET_UNKNOWN
)
11084 error (_("Remote target doesn't support qGetTIBAddr packet"));
11086 error (_("Remote target failed to process qGetTIBAddr request"));
11089 error (_("qGetTIBAddr not supported or disabled on this target"));
11094 /* Support for inferring a target description based on the current
11095 architecture and the size of a 'g' packet. While the 'g' packet
11096 can have any size (since optional registers can be left off the
11097 end), some sizes are easily recognizable given knowledge of the
11098 approximate architecture. */
11100 struct remote_g_packet_guess
11103 const struct target_desc
*tdesc
;
11105 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
11106 DEF_VEC_O(remote_g_packet_guess_s
);
11108 struct remote_g_packet_data
11110 VEC(remote_g_packet_guess_s
) *guesses
;
11113 static struct gdbarch_data
*remote_g_packet_data_handle
;
11116 remote_g_packet_data_init (struct obstack
*obstack
)
11118 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
11122 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11123 const struct target_desc
*tdesc
)
11125 struct remote_g_packet_data
*data
11126 = ((struct remote_g_packet_data
*)
11127 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11128 struct remote_g_packet_guess new_guess
, *guess
;
11131 gdb_assert (tdesc
!= NULL
);
11134 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11136 if (guess
->bytes
== bytes
)
11137 internal_error (__FILE__
, __LINE__
,
11138 _("Duplicate g packet description added for size %d"),
11141 new_guess
.bytes
= bytes
;
11142 new_guess
.tdesc
= tdesc
;
11143 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
11146 /* Return 1 if remote_read_description would do anything on this target
11147 and architecture, 0 otherwise. */
11150 remote_read_description_p (struct target_ops
*target
)
11152 struct remote_g_packet_data
*data
11153 = ((struct remote_g_packet_data
*)
11154 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11156 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11162 static const struct target_desc
*
11163 remote_read_description (struct target_ops
*target
)
11165 struct remote_g_packet_data
*data
11166 = ((struct remote_g_packet_data
*)
11167 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11169 /* Do not try this during initial connection, when we do not know
11170 whether there is a running but stopped thread. */
11171 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
11172 return target
->beneath
->to_read_description (target
->beneath
);
11174 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11176 struct remote_g_packet_guess
*guess
;
11178 int bytes
= send_g_packet ();
11181 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11183 if (guess
->bytes
== bytes
)
11184 return guess
->tdesc
;
11186 /* We discard the g packet. A minor optimization would be to
11187 hold on to it, and fill the register cache once we have selected
11188 an architecture, but it's too tricky to do safely. */
11191 return target
->beneath
->to_read_description (target
->beneath
);
11194 /* Remote file transfer support. This is host-initiated I/O, not
11195 target-initiated; for target-initiated, see remote-fileio.c. */
11197 /* If *LEFT is at least the length of STRING, copy STRING to
11198 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11199 decrease *LEFT. Otherwise raise an error. */
11202 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11204 int len
= strlen (string
);
11207 error (_("Packet too long for target."));
11209 memcpy (*buffer
, string
, len
);
11213 /* NUL-terminate the buffer as a convenience, if there is
11219 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11220 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11221 decrease *LEFT. Otherwise raise an error. */
11224 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11227 if (2 * len
> *left
)
11228 error (_("Packet too long for target."));
11230 bin2hex (bytes
, *buffer
, len
);
11231 *buffer
+= 2 * len
;
11234 /* NUL-terminate the buffer as a convenience, if there is
11240 /* If *LEFT is large enough, convert VALUE to hex and add it to
11241 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11242 decrease *LEFT. Otherwise raise an error. */
11245 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11247 int len
= hexnumlen (value
);
11250 error (_("Packet too long for target."));
11252 hexnumstr (*buffer
, value
);
11256 /* NUL-terminate the buffer as a convenience, if there is
11262 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11263 value, *REMOTE_ERRNO to the remote error number or zero if none
11264 was included, and *ATTACHMENT to point to the start of the annex
11265 if any. The length of the packet isn't needed here; there may
11266 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11268 Return 0 if the packet could be parsed, -1 if it could not. If
11269 -1 is returned, the other variables may not be initialized. */
11272 remote_hostio_parse_result (char *buffer
, int *retcode
,
11273 int *remote_errno
, char **attachment
)
11278 *attachment
= NULL
;
11280 if (buffer
[0] != 'F')
11284 *retcode
= strtol (&buffer
[1], &p
, 16);
11285 if (errno
!= 0 || p
== &buffer
[1])
11288 /* Check for ",errno". */
11292 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11293 if (errno
!= 0 || p
+ 1 == p2
)
11298 /* Check for ";attachment". If there is no attachment, the
11299 packet should end here. */
11302 *attachment
= p
+ 1;
11305 else if (*p
== '\0')
11311 /* Send a prepared I/O packet to the target and read its response.
11312 The prepared packet is in the global RS->BUF before this function
11313 is called, and the answer is there when we return.
11315 COMMAND_BYTES is the length of the request to send, which may include
11316 binary data. WHICH_PACKET is the packet configuration to check
11317 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11318 is set to the error number and -1 is returned. Otherwise the value
11319 returned by the function is returned.
11321 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11322 attachment is expected; an error will be reported if there's a
11323 mismatch. If one is found, *ATTACHMENT will be set to point into
11324 the packet buffer and *ATTACHMENT_LEN will be set to the
11325 attachment's length. */
11328 remote_hostio_send_command (int command_bytes
, int which_packet
,
11329 int *remote_errno
, char **attachment
,
11330 int *attachment_len
)
11332 struct remote_state
*rs
= get_remote_state ();
11333 int ret
, bytes_read
;
11334 char *attachment_tmp
;
11336 if (!rs
->remote_desc
11337 || packet_support (which_packet
) == PACKET_DISABLE
)
11339 *remote_errno
= FILEIO_ENOSYS
;
11343 putpkt_binary (rs
->buf
, command_bytes
);
11344 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
11346 /* If it timed out, something is wrong. Don't try to parse the
11348 if (bytes_read
< 0)
11350 *remote_errno
= FILEIO_EINVAL
;
11354 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11357 *remote_errno
= FILEIO_EINVAL
;
11359 case PACKET_UNKNOWN
:
11360 *remote_errno
= FILEIO_ENOSYS
;
11366 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
11369 *remote_errno
= FILEIO_EINVAL
;
11373 /* Make sure we saw an attachment if and only if we expected one. */
11374 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11375 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11377 *remote_errno
= FILEIO_EINVAL
;
11381 /* If an attachment was found, it must point into the packet buffer;
11382 work out how many bytes there were. */
11383 if (attachment_tmp
!= NULL
)
11385 *attachment
= attachment_tmp
;
11386 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
11392 /* Invalidate the readahead cache. */
11395 readahead_cache_invalidate (void)
11397 struct remote_state
*rs
= get_remote_state ();
11399 rs
->readahead_cache
.fd
= -1;
11402 /* Invalidate the readahead cache if it is holding data for FD. */
11405 readahead_cache_invalidate_fd (int fd
)
11407 struct remote_state
*rs
= get_remote_state ();
11409 if (rs
->readahead_cache
.fd
== fd
)
11410 rs
->readahead_cache
.fd
= -1;
11413 /* Set the filesystem remote_hostio functions that take FILENAME
11414 arguments will use. Return 0 on success, or -1 if an error
11415 occurs (and set *REMOTE_ERRNO). */
11418 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
11420 struct remote_state
*rs
= get_remote_state ();
11421 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11423 int left
= get_remote_packet_size () - 1;
11427 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11430 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11433 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11435 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11436 remote_buffer_add_string (&p
, &left
, arg
);
11438 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
11439 remote_errno
, NULL
, NULL
);
11441 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11445 rs
->fs_pid
= required_pid
;
11450 /* Implementation of to_fileio_open. */
11453 remote_hostio_open (struct target_ops
*self
,
11454 struct inferior
*inf
, const char *filename
,
11455 int flags
, int mode
, int warn_if_slow
,
11458 struct remote_state
*rs
= get_remote_state ();
11460 int left
= get_remote_packet_size () - 1;
11464 static int warning_issued
= 0;
11466 printf_unfiltered (_("Reading %s from remote target...\n"),
11469 if (!warning_issued
)
11471 warning (_("File transfers from remote targets can be slow."
11472 " Use \"set sysroot\" to access files locally"
11474 warning_issued
= 1;
11478 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11481 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11483 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11484 strlen (filename
));
11485 remote_buffer_add_string (&p
, &left
, ",");
11487 remote_buffer_add_int (&p
, &left
, flags
);
11488 remote_buffer_add_string (&p
, &left
, ",");
11490 remote_buffer_add_int (&p
, &left
, mode
);
11492 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
11493 remote_errno
, NULL
, NULL
);
11496 /* Implementation of to_fileio_pwrite. */
11499 remote_hostio_pwrite (struct target_ops
*self
,
11500 int fd
, const gdb_byte
*write_buf
, int len
,
11501 ULONGEST offset
, int *remote_errno
)
11503 struct remote_state
*rs
= get_remote_state ();
11505 int left
= get_remote_packet_size ();
11508 readahead_cache_invalidate_fd (fd
);
11510 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11512 remote_buffer_add_int (&p
, &left
, fd
);
11513 remote_buffer_add_string (&p
, &left
, ",");
11515 remote_buffer_add_int (&p
, &left
, offset
);
11516 remote_buffer_add_string (&p
, &left
, ",");
11518 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11519 get_remote_packet_size () - (p
- rs
->buf
));
11521 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
11522 remote_errno
, NULL
, NULL
);
11525 /* Helper for the implementation of to_fileio_pread. Read the file
11526 from the remote side with vFile:pread. */
11529 remote_hostio_pread_vFile (struct target_ops
*self
,
11530 int fd
, gdb_byte
*read_buf
, int len
,
11531 ULONGEST offset
, int *remote_errno
)
11533 struct remote_state
*rs
= get_remote_state ();
11536 int left
= get_remote_packet_size ();
11537 int ret
, attachment_len
;
11540 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11542 remote_buffer_add_int (&p
, &left
, fd
);
11543 remote_buffer_add_string (&p
, &left
, ",");
11545 remote_buffer_add_int (&p
, &left
, len
);
11546 remote_buffer_add_string (&p
, &left
, ",");
11548 remote_buffer_add_int (&p
, &left
, offset
);
11550 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
11551 remote_errno
, &attachment
,
11557 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11559 if (read_len
!= ret
)
11560 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11565 /* Serve pread from the readahead cache. Returns number of bytes
11566 read, or 0 if the request can't be served from the cache. */
11569 remote_hostio_pread_from_cache (struct remote_state
*rs
,
11570 int fd
, gdb_byte
*read_buf
, size_t len
,
11573 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11575 if (cache
->fd
== fd
11576 && cache
->offset
<= offset
11577 && offset
< cache
->offset
+ cache
->bufsize
)
11579 ULONGEST max
= cache
->offset
+ cache
->bufsize
;
11581 if (offset
+ len
> max
)
11582 len
= max
- offset
;
11584 memcpy (read_buf
, cache
->buf
+ offset
- cache
->offset
, len
);
11591 /* Implementation of to_fileio_pread. */
11594 remote_hostio_pread (struct target_ops
*self
,
11595 int fd
, gdb_byte
*read_buf
, int len
,
11596 ULONGEST offset
, int *remote_errno
)
11599 struct remote_state
*rs
= get_remote_state ();
11600 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11602 ret
= remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11605 cache
->hit_count
++;
11608 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
11609 pulongest (cache
->hit_count
));
11613 cache
->miss_count
++;
11615 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
11616 pulongest (cache
->miss_count
));
11619 cache
->offset
= offset
;
11620 cache
->bufsize
= get_remote_packet_size ();
11621 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
11623 ret
= remote_hostio_pread_vFile (self
, cache
->fd
, cache
->buf
, cache
->bufsize
,
11624 cache
->offset
, remote_errno
);
11627 readahead_cache_invalidate_fd (fd
);
11631 cache
->bufsize
= ret
;
11632 return remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11635 /* Implementation of to_fileio_close. */
11638 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
11640 struct remote_state
*rs
= get_remote_state ();
11642 int left
= get_remote_packet_size () - 1;
11644 readahead_cache_invalidate_fd (fd
);
11646 remote_buffer_add_string (&p
, &left
, "vFile:close:");
11648 remote_buffer_add_int (&p
, &left
, fd
);
11650 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
11651 remote_errno
, NULL
, NULL
);
11654 /* Implementation of to_fileio_unlink. */
11657 remote_hostio_unlink (struct target_ops
*self
,
11658 struct inferior
*inf
, const char *filename
,
11661 struct remote_state
*rs
= get_remote_state ();
11663 int left
= get_remote_packet_size () - 1;
11665 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11668 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
11670 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11671 strlen (filename
));
11673 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
11674 remote_errno
, NULL
, NULL
);
11677 /* Implementation of to_fileio_readlink. */
11680 remote_hostio_readlink (struct target_ops
*self
,
11681 struct inferior
*inf
, const char *filename
,
11684 struct remote_state
*rs
= get_remote_state ();
11687 int left
= get_remote_packet_size ();
11688 int len
, attachment_len
;
11692 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11695 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
11697 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11698 strlen (filename
));
11700 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
11701 remote_errno
, &attachment
,
11707 ret
= (char *) xmalloc (len
+ 1);
11709 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11710 (gdb_byte
*) ret
, len
);
11711 if (read_len
!= len
)
11712 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
11718 /* Implementation of to_fileio_fstat. */
11721 remote_hostio_fstat (struct target_ops
*self
,
11722 int fd
, struct stat
*st
,
11725 struct remote_state
*rs
= get_remote_state ();
11727 int left
= get_remote_packet_size ();
11728 int attachment_len
, ret
;
11730 struct fio_stat fst
;
11733 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
11735 remote_buffer_add_int (&p
, &left
, fd
);
11737 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
11738 remote_errno
, &attachment
,
11742 if (*remote_errno
!= FILEIO_ENOSYS
)
11745 /* Strictly we should return -1, ENOSYS here, but when
11746 "set sysroot remote:" was implemented in August 2008
11747 BFD's need for a stat function was sidestepped with
11748 this hack. This was not remedied until March 2015
11749 so we retain the previous behavior to avoid breaking
11752 Note that the memset is a March 2015 addition; older
11753 GDBs set st_size *and nothing else* so the structure
11754 would have garbage in all other fields. This might
11755 break something but retaining the previous behavior
11756 here would be just too wrong. */
11758 memset (st
, 0, sizeof (struct stat
));
11759 st
->st_size
= INT_MAX
;
11763 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11764 (gdb_byte
*) &fst
, sizeof (fst
));
11766 if (read_len
!= ret
)
11767 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
11769 if (read_len
!= sizeof (fst
))
11770 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11771 read_len
, (int) sizeof (fst
));
11773 remote_fileio_to_host_stat (&fst
, st
);
11778 /* Implementation of to_filesystem_is_local. */
11781 remote_filesystem_is_local (struct target_ops
*self
)
11783 /* Valgrind GDB presents itself as a remote target but works
11784 on the local filesystem: it does not implement remote get
11785 and users are not expected to set a sysroot. To handle
11786 this case we treat the remote filesystem as local if the
11787 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11788 does not support vFile:open. */
11789 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
11791 enum packet_support ps
= packet_support (PACKET_vFile_open
);
11793 if (ps
== PACKET_SUPPORT_UNKNOWN
)
11795 int fd
, remote_errno
;
11797 /* Try opening a file to probe support. The supplied
11798 filename is irrelevant, we only care about whether
11799 the stub recognizes the packet or not. */
11800 fd
= remote_hostio_open (self
, NULL
, "just probing",
11801 FILEIO_O_RDONLY
, 0700, 0,
11805 remote_hostio_close (self
, fd
, &remote_errno
);
11807 ps
= packet_support (PACKET_vFile_open
);
11810 if (ps
== PACKET_DISABLE
)
11812 static int warning_issued
= 0;
11814 if (!warning_issued
)
11816 warning (_("remote target does not support file"
11817 " transfer, attempting to access files"
11818 " from local filesystem."));
11819 warning_issued
= 1;
11830 remote_fileio_errno_to_host (int errnum
)
11836 case FILEIO_ENOENT
:
11844 case FILEIO_EACCES
:
11846 case FILEIO_EFAULT
:
11850 case FILEIO_EEXIST
:
11852 case FILEIO_ENODEV
:
11854 case FILEIO_ENOTDIR
:
11856 case FILEIO_EISDIR
:
11858 case FILEIO_EINVAL
:
11860 case FILEIO_ENFILE
:
11862 case FILEIO_EMFILE
:
11866 case FILEIO_ENOSPC
:
11868 case FILEIO_ESPIPE
:
11872 case FILEIO_ENOSYS
:
11874 case FILEIO_ENAMETOOLONG
:
11875 return ENAMETOOLONG
;
11881 remote_hostio_error (int errnum
)
11883 int host_error
= remote_fileio_errno_to_host (errnum
);
11885 if (host_error
== -1)
11886 error (_("Unknown remote I/O error %d"), errnum
);
11888 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
11892 remote_hostio_close_cleanup (void *opaque
)
11894 int fd
= *(int *) opaque
;
11897 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
11901 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
11903 struct cleanup
*back_to
, *close_cleanup
;
11904 int retcode
, fd
, remote_errno
, bytes
, io_size
;
11907 int bytes_in_buffer
;
11910 struct remote_state
*rs
= get_remote_state ();
11912 if (!rs
->remote_desc
)
11913 error (_("command can only be used with remote target"));
11915 file
= gdb_fopen_cloexec (local_file
, "rb");
11917 perror_with_name (local_file
);
11918 back_to
= make_cleanup_fclose (file
);
11920 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11921 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
11923 0700, 0, &remote_errno
);
11925 remote_hostio_error (remote_errno
);
11927 /* Send up to this many bytes at once. They won't all fit in the
11928 remote packet limit, so we'll transfer slightly fewer. */
11929 io_size
= get_remote_packet_size ();
11930 buffer
= (gdb_byte
*) xmalloc (io_size
);
11931 make_cleanup (xfree
, buffer
);
11933 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11935 bytes_in_buffer
= 0;
11938 while (bytes_in_buffer
|| !saw_eof
)
11942 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
11943 io_size
- bytes_in_buffer
,
11948 error (_("Error reading %s."), local_file
);
11951 /* EOF. Unless there is something still in the
11952 buffer from the last iteration, we are done. */
11954 if (bytes_in_buffer
== 0)
11962 bytes
+= bytes_in_buffer
;
11963 bytes_in_buffer
= 0;
11965 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
11967 offset
, &remote_errno
);
11970 remote_hostio_error (remote_errno
);
11971 else if (retcode
== 0)
11972 error (_("Remote write of %d bytes returned 0!"), bytes
);
11973 else if (retcode
< bytes
)
11975 /* Short write. Save the rest of the read data for the next
11977 bytes_in_buffer
= bytes
- retcode
;
11978 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
11984 discard_cleanups (close_cleanup
);
11985 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
11986 remote_hostio_error (remote_errno
);
11989 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
11990 do_cleanups (back_to
);
11994 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
11996 struct cleanup
*back_to
, *close_cleanup
;
11997 int fd
, remote_errno
, bytes
, io_size
;
12001 struct remote_state
*rs
= get_remote_state ();
12003 if (!rs
->remote_desc
)
12004 error (_("command can only be used with remote target"));
12006 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
12007 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12010 remote_hostio_error (remote_errno
);
12012 file
= gdb_fopen_cloexec (local_file
, "wb");
12014 perror_with_name (local_file
);
12015 back_to
= make_cleanup_fclose (file
);
12017 /* Send up to this many bytes at once. They won't all fit in the
12018 remote packet limit, so we'll transfer slightly fewer. */
12019 io_size
= get_remote_packet_size ();
12020 buffer
= (gdb_byte
*) xmalloc (io_size
);
12021 make_cleanup (xfree
, buffer
);
12023 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
12028 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
12029 fd
, buffer
, io_size
, offset
, &remote_errno
);
12031 /* Success, but no bytes, means end-of-file. */
12034 remote_hostio_error (remote_errno
);
12038 bytes
= fwrite (buffer
, 1, bytes
, file
);
12040 perror_with_name (local_file
);
12043 discard_cleanups (close_cleanup
);
12044 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12045 remote_hostio_error (remote_errno
);
12048 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12049 do_cleanups (back_to
);
12053 remote_file_delete (const char *remote_file
, int from_tty
)
12055 int retcode
, remote_errno
;
12056 struct remote_state
*rs
= get_remote_state ();
12058 if (!rs
->remote_desc
)
12059 error (_("command can only be used with remote target"));
12061 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
12062 NULL
, remote_file
, &remote_errno
);
12064 remote_hostio_error (remote_errno
);
12067 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12071 remote_put_command (char *args
, int from_tty
)
12073 struct cleanup
*back_to
;
12077 error_no_arg (_("file to put"));
12079 argv
= gdb_buildargv (args
);
12080 back_to
= make_cleanup_freeargv (argv
);
12081 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12082 error (_("Invalid parameters to remote put"));
12084 remote_file_put (argv
[0], argv
[1], from_tty
);
12086 do_cleanups (back_to
);
12090 remote_get_command (char *args
, int from_tty
)
12092 struct cleanup
*back_to
;
12096 error_no_arg (_("file to get"));
12098 argv
= gdb_buildargv (args
);
12099 back_to
= make_cleanup_freeargv (argv
);
12100 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12101 error (_("Invalid parameters to remote get"));
12103 remote_file_get (argv
[0], argv
[1], from_tty
);
12105 do_cleanups (back_to
);
12109 remote_delete_command (char *args
, int from_tty
)
12111 struct cleanup
*back_to
;
12115 error_no_arg (_("file to delete"));
12117 argv
= gdb_buildargv (args
);
12118 back_to
= make_cleanup_freeargv (argv
);
12119 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12120 error (_("Invalid parameters to remote delete"));
12122 remote_file_delete (argv
[0], from_tty
);
12124 do_cleanups (back_to
);
12128 remote_command (char *args
, int from_tty
)
12130 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12134 remote_can_execute_reverse (struct target_ops
*self
)
12136 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12137 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12144 remote_supports_non_stop (struct target_ops
*self
)
12150 remote_supports_disable_randomization (struct target_ops
*self
)
12152 /* Only supported in extended mode. */
12157 remote_supports_multi_process (struct target_ops
*self
)
12159 struct remote_state
*rs
= get_remote_state ();
12161 return remote_multi_process_p (rs
);
12165 remote_supports_cond_tracepoints (void)
12167 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12171 remote_supports_cond_breakpoints (struct target_ops
*self
)
12173 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12177 remote_supports_fast_tracepoints (void)
12179 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12183 remote_supports_static_tracepoints (void)
12185 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12189 remote_supports_install_in_trace (void)
12191 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12195 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
12197 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12202 remote_supports_string_tracing (struct target_ops
*self
)
12204 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12208 remote_can_run_breakpoint_commands (struct target_ops
*self
)
12210 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12214 remote_trace_init (struct target_ops
*self
)
12217 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12218 if (strcmp (target_buf
, "OK") != 0)
12219 error (_("Target does not support this command."));
12222 static void free_actions_list (char **actions_list
);
12223 static void free_actions_list_cleanup_wrapper (void *);
12225 free_actions_list_cleanup_wrapper (void *al
)
12227 free_actions_list ((char **) al
);
12231 free_actions_list (char **actions_list
)
12235 if (actions_list
== 0)
12238 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
12239 xfree (actions_list
[ndx
]);
12241 xfree (actions_list
);
12244 /* Recursive routine to walk through command list including loops, and
12245 download packets for each command. */
12248 remote_download_command_source (int num
, ULONGEST addr
,
12249 struct command_line
*cmds
)
12251 struct remote_state
*rs
= get_remote_state ();
12252 struct command_line
*cmd
;
12254 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12256 QUIT
; /* Allow user to bail out with ^C. */
12257 strcpy (rs
->buf
, "QTDPsrc:");
12258 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12259 rs
->buf
+ strlen (rs
->buf
),
12260 rs
->buf_size
- strlen (rs
->buf
));
12262 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12263 if (strcmp (target_buf
, "OK"))
12264 warning (_("Target does not support source download."));
12266 if (cmd
->control_type
== while_control
12267 || cmd
->control_type
== while_stepping_control
)
12269 remote_download_command_source (num
, addr
, *cmd
->body_list
);
12271 QUIT
; /* Allow user to bail out with ^C. */
12272 strcpy (rs
->buf
, "QTDPsrc:");
12273 encode_source_string (num
, addr
, "cmd", "end",
12274 rs
->buf
+ strlen (rs
->buf
),
12275 rs
->buf_size
- strlen (rs
->buf
));
12277 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12278 if (strcmp (target_buf
, "OK"))
12279 warning (_("Target does not support source download."));
12285 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
12287 #define BUF_SIZE 2048
12291 char buf
[BUF_SIZE
];
12292 char **tdp_actions
;
12293 char **stepping_actions
;
12295 struct cleanup
*old_chain
= NULL
;
12297 struct breakpoint
*b
= loc
->owner
;
12298 struct tracepoint
*t
= (struct tracepoint
*) b
;
12300 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12301 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
12303 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
12306 tpaddr
= loc
->address
;
12307 sprintf_vma (addrbuf
, tpaddr
);
12308 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
12309 addrbuf
, /* address */
12310 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12311 t
->step_count
, t
->pass_count
);
12312 /* Fast tracepoints are mostly handled by the target, but we can
12313 tell the target how big of an instruction block should be moved
12315 if (b
->type
== bp_fast_tracepoint
)
12317 /* Only test for support at download time; we may not know
12318 target capabilities at definition time. */
12319 if (remote_supports_fast_tracepoints ())
12321 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12323 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
12324 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12326 /* If it passed validation at definition but fails now,
12327 something is very wrong. */
12328 internal_error (__FILE__
, __LINE__
,
12329 _("Fast tracepoint not "
12330 "valid during download"));
12333 /* Fast tracepoints are functionally identical to regular
12334 tracepoints, so don't take lack of support as a reason to
12335 give up on the trace run. */
12336 warning (_("Target does not support fast tracepoints, "
12337 "downloading %d as regular tracepoint"), b
->number
);
12339 else if (b
->type
== bp_static_tracepoint
)
12341 /* Only test for support at download time; we may not know
12342 target capabilities at definition time. */
12343 if (remote_supports_static_tracepoints ())
12345 struct static_tracepoint_marker marker
;
12347 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12348 strcat (buf
, ":S");
12350 error (_("Static tracepoint not valid during download"));
12353 /* Fast tracepoints are functionally identical to regular
12354 tracepoints, so don't take lack of support as a reason
12355 to give up on the trace run. */
12356 error (_("Target does not support static tracepoints"));
12358 /* If the tracepoint has a conditional, make it into an agent
12359 expression and append to the definition. */
12362 /* Only test support at download time, we may not know target
12363 capabilities at definition time. */
12364 if (remote_supports_cond_tracepoints ())
12366 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
.get ());
12367 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
12369 pkt
= buf
+ strlen (buf
);
12370 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12371 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12375 warning (_("Target does not support conditional tracepoints, "
12376 "ignoring tp %d cond"), b
->number
);
12379 if (b
->commands
|| *default_collect
)
12382 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12383 if (strcmp (target_buf
, "OK"))
12384 error (_("Target does not support tracepoints."));
12386 /* do_single_steps (t); */
12389 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
12391 QUIT
; /* Allow user to bail out with ^C. */
12392 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
12393 b
->number
, addrbuf
, /* address */
12395 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
12398 remote_get_noisy_reply (&target_buf
,
12400 if (strcmp (target_buf
, "OK"))
12401 error (_("Error on target while setting tracepoints."));
12404 if (stepping_actions
)
12406 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
12408 QUIT
; /* Allow user to bail out with ^C. */
12409 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
12410 b
->number
, addrbuf
, /* address */
12411 ((ndx
== 0) ? "S" : ""),
12412 stepping_actions
[ndx
],
12413 (stepping_actions
[ndx
+ 1] ? "-" : ""));
12415 remote_get_noisy_reply (&target_buf
,
12417 if (strcmp (target_buf
, "OK"))
12418 error (_("Error on target while setting tracepoints."));
12422 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12424 if (b
->location
!= NULL
)
12426 strcpy (buf
, "QTDPsrc:");
12427 encode_source_string (b
->number
, loc
->address
, "at",
12428 event_location_to_string (b
->location
.get ()),
12429 buf
+ strlen (buf
), 2048 - strlen (buf
));
12431 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12432 if (strcmp (target_buf
, "OK"))
12433 warning (_("Target does not support source download."));
12435 if (b
->cond_string
)
12437 strcpy (buf
, "QTDPsrc:");
12438 encode_source_string (b
->number
, loc
->address
,
12439 "cond", b
->cond_string
, buf
+ strlen (buf
),
12440 2048 - strlen (buf
));
12442 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12443 if (strcmp (target_buf
, "OK"))
12444 warning (_("Target does not support source download."));
12446 remote_download_command_source (b
->number
, loc
->address
,
12447 breakpoint_commands (b
));
12450 do_cleanups (old_chain
);
12454 remote_can_download_tracepoint (struct target_ops
*self
)
12456 struct remote_state
*rs
= get_remote_state ();
12457 struct trace_status
*ts
;
12460 /* Don't try to install tracepoints until we've relocated our
12461 symbols, and fetched and merged the target's tracepoint list with
12463 if (rs
->starting_up
)
12466 ts
= current_trace_status ();
12467 status
= remote_get_trace_status (self
, ts
);
12469 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12472 /* If we are in a tracing experiment, but remote stub doesn't support
12473 installing tracepoint in trace, we have to return. */
12474 if (!remote_supports_install_in_trace ())
12482 remote_download_trace_state_variable (struct target_ops
*self
,
12483 struct trace_state_variable
*tsv
)
12485 struct remote_state
*rs
= get_remote_state ();
12488 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12489 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
12491 p
= rs
->buf
+ strlen (rs
->buf
);
12492 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
12493 error (_("Trace state variable name too long for tsv definition packet"));
12494 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
12497 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12498 if (*target_buf
== '\0')
12499 error (_("Target does not support this command."));
12500 if (strcmp (target_buf
, "OK") != 0)
12501 error (_("Error on target while downloading trace state variable."));
12505 remote_enable_tracepoint (struct target_ops
*self
,
12506 struct bp_location
*location
)
12508 struct remote_state
*rs
= get_remote_state ();
12511 sprintf_vma (addr_buf
, location
->address
);
12512 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
12513 location
->owner
->number
, addr_buf
);
12515 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12516 if (*rs
->buf
== '\0')
12517 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12518 if (strcmp (rs
->buf
, "OK") != 0)
12519 error (_("Error on target while enabling tracepoint."));
12523 remote_disable_tracepoint (struct target_ops
*self
,
12524 struct bp_location
*location
)
12526 struct remote_state
*rs
= get_remote_state ();
12529 sprintf_vma (addr_buf
, location
->address
);
12530 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
12531 location
->owner
->number
, addr_buf
);
12533 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12534 if (*rs
->buf
== '\0')
12535 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12536 if (strcmp (rs
->buf
, "OK") != 0)
12537 error (_("Error on target while disabling tracepoint."));
12541 remote_trace_set_readonly_regions (struct target_ops
*self
)
12545 bfd_size_type size
;
12551 return; /* No information to give. */
12553 strcpy (target_buf
, "QTro");
12554 offset
= strlen (target_buf
);
12555 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
12557 char tmp1
[40], tmp2
[40];
12560 if ((s
->flags
& SEC_LOAD
) == 0 ||
12561 /* (s->flags & SEC_CODE) == 0 || */
12562 (s
->flags
& SEC_READONLY
) == 0)
12566 vma
= bfd_get_section_vma (abfd
, s
);
12567 size
= bfd_get_section_size (s
);
12568 sprintf_vma (tmp1
, vma
);
12569 sprintf_vma (tmp2
, vma
+ size
);
12570 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
12571 if (offset
+ sec_length
+ 1 > target_buf_size
)
12573 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
12575 Too many sections for read-only sections definition packet."));
12578 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
12580 offset
+= sec_length
;
12584 putpkt (target_buf
);
12585 getpkt (&target_buf
, &target_buf_size
, 0);
12590 remote_trace_start (struct target_ops
*self
)
12592 putpkt ("QTStart");
12593 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12594 if (*target_buf
== '\0')
12595 error (_("Target does not support this command."));
12596 if (strcmp (target_buf
, "OK") != 0)
12597 error (_("Bogus reply from target: %s"), target_buf
);
12601 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
12603 /* Initialize it just to avoid a GCC false warning. */
12605 /* FIXME we need to get register block size some other way. */
12606 extern int trace_regblock_size
;
12607 enum packet_result result
;
12609 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
12612 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
12614 putpkt ("qTStatus");
12618 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12620 CATCH (ex
, RETURN_MASK_ERROR
)
12622 if (ex
.error
!= TARGET_CLOSE_ERROR
)
12624 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
12627 throw_exception (ex
);
12631 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
12633 /* If the remote target doesn't do tracing, flag it. */
12634 if (result
== PACKET_UNKNOWN
)
12637 /* We're working with a live target. */
12638 ts
->filename
= NULL
;
12641 error (_("Bogus trace status reply from target: %s"), target_buf
);
12643 /* Function 'parse_trace_status' sets default value of each field of
12644 'ts' at first, so we don't have to do it here. */
12645 parse_trace_status (p
, ts
);
12647 return ts
->running
;
12651 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
12652 struct uploaded_tp
*utp
)
12654 struct remote_state
*rs
= get_remote_state ();
12656 struct bp_location
*loc
;
12657 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
12658 size_t size
= get_remote_packet_size ();
12663 tp
->traceframe_usage
= 0;
12664 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
12666 /* If the tracepoint was never downloaded, don't go asking for
12668 if (tp
->number_on_target
== 0)
12670 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
12671 phex_nz (loc
->address
, 0));
12673 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12674 if (reply
&& *reply
)
12677 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12683 utp
->hit_count
= 0;
12684 utp
->traceframe_usage
= 0;
12685 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
12686 phex_nz (utp
->addr
, 0));
12688 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12689 if (reply
&& *reply
)
12692 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12698 remote_trace_stop (struct target_ops
*self
)
12701 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12702 if (*target_buf
== '\0')
12703 error (_("Target does not support this command."));
12704 if (strcmp (target_buf
, "OK") != 0)
12705 error (_("Bogus reply from target: %s"), target_buf
);
12709 remote_trace_find (struct target_ops
*self
,
12710 enum trace_find_type type
, int num
,
12711 CORE_ADDR addr1
, CORE_ADDR addr2
,
12714 struct remote_state
*rs
= get_remote_state ();
12715 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12717 int target_frameno
= -1, target_tracept
= -1;
12719 /* Lookups other than by absolute frame number depend on the current
12720 trace selected, so make sure it is correct on the remote end
12722 if (type
!= tfind_number
)
12723 set_remote_traceframe ();
12726 strcpy (p
, "QTFrame:");
12727 p
= strchr (p
, '\0');
12731 xsnprintf (p
, endbuf
- p
, "%x", num
);
12734 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
12737 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
12740 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
12741 phex_nz (addr2
, 0));
12743 case tfind_outside
:
12744 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
12745 phex_nz (addr2
, 0));
12748 error (_("Unknown trace find type %d"), type
);
12752 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
12753 if (*reply
== '\0')
12754 error (_("Target does not support this command."));
12756 while (reply
&& *reply
)
12761 target_frameno
= (int) strtol (p
, &reply
, 16);
12763 error (_("Unable to parse trace frame number"));
12764 /* Don't update our remote traceframe number cache on failure
12765 to select a remote traceframe. */
12766 if (target_frameno
== -1)
12771 target_tracept
= (int) strtol (p
, &reply
, 16);
12773 error (_("Unable to parse tracepoint number"));
12775 case 'O': /* "OK"? */
12776 if (reply
[1] == 'K' && reply
[2] == '\0')
12779 error (_("Bogus reply from target: %s"), reply
);
12782 error (_("Bogus reply from target: %s"), reply
);
12785 *tpp
= target_tracept
;
12787 rs
->remote_traceframe_number
= target_frameno
;
12788 return target_frameno
;
12792 remote_get_trace_state_variable_value (struct target_ops
*self
,
12793 int tsvnum
, LONGEST
*val
)
12795 struct remote_state
*rs
= get_remote_state ();
12799 set_remote_traceframe ();
12801 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
12803 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12804 if (reply
&& *reply
)
12808 unpack_varlen_hex (reply
+ 1, &uval
);
12809 *val
= (LONGEST
) uval
;
12817 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
12819 struct remote_state
*rs
= get_remote_state ();
12823 strcpy (p
, "QTSave:");
12825 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
12826 error (_("Remote file name too long for trace save packet"));
12827 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
12830 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12831 if (*reply
== '\0')
12832 error (_("Target does not support this command."));
12833 if (strcmp (reply
, "OK") != 0)
12834 error (_("Bogus reply from target: %s"), reply
);
12838 /* This is basically a memory transfer, but needs to be its own packet
12839 because we don't know how the target actually organizes its trace
12840 memory, plus we want to be able to ask for as much as possible, but
12841 not be unhappy if we don't get as much as we ask for. */
12844 remote_get_raw_trace_data (struct target_ops
*self
,
12845 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
12847 struct remote_state
*rs
= get_remote_state ();
12853 strcpy (p
, "qTBuffer:");
12855 p
+= hexnumstr (p
, offset
);
12857 p
+= hexnumstr (p
, len
);
12861 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12862 if (reply
&& *reply
)
12864 /* 'l' by itself means we're at the end of the buffer and
12865 there is nothing more to get. */
12869 /* Convert the reply into binary. Limit the number of bytes to
12870 convert according to our passed-in buffer size, rather than
12871 what was returned in the packet; if the target is
12872 unexpectedly generous and gives us a bigger reply than we
12873 asked for, we don't want to crash. */
12874 rslt
= hex2bin (target_buf
, buf
, len
);
12878 /* Something went wrong, flag as an error. */
12883 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
12885 struct remote_state
*rs
= get_remote_state ();
12887 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
12891 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
12893 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12894 if (*reply
== '\0')
12895 error (_("Target does not support this command."));
12896 if (strcmp (reply
, "OK") != 0)
12897 error (_("Bogus reply from target: %s"), reply
);
12900 warning (_("Target does not support disconnected tracing."));
12904 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
12906 struct thread_info
*info
= find_thread_ptid (ptid
);
12908 if (info
&& info
->priv
)
12909 return info
->priv
->core
;
12914 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
12916 struct remote_state
*rs
= get_remote_state ();
12919 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
12921 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12922 if (*reply
== '\0')
12923 error (_("Target does not support this command."));
12924 if (strcmp (reply
, "OK") != 0)
12925 error (_("Bogus reply from target: %s"), reply
);
12928 static struct traceframe_info
*
12929 remote_traceframe_info (struct target_ops
*self
)
12933 text
= target_read_stralloc (¤t_target
,
12934 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
12937 struct traceframe_info
*info
;
12938 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
12940 info
= parse_traceframe_info (text
);
12941 do_cleanups (back_to
);
12948 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12949 instruction on which a fast tracepoint may be placed. Returns -1
12950 if the packet is not supported, and 0 if the minimum instruction
12951 length is unknown. */
12954 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
12956 struct remote_state
*rs
= get_remote_state ();
12959 /* If we're not debugging a process yet, the IPA can't be
12961 if (!target_has_execution
)
12964 /* Make sure the remote is pointing at the right process. */
12965 set_general_process ();
12967 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
12969 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12970 if (*reply
== '\0')
12974 ULONGEST min_insn_len
;
12976 unpack_varlen_hex (reply
, &min_insn_len
);
12978 return (int) min_insn_len
;
12983 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
12985 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
12987 struct remote_state
*rs
= get_remote_state ();
12988 char *buf
= rs
->buf
;
12989 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12990 enum packet_result result
;
12992 gdb_assert (val
>= 0 || val
== -1);
12993 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
12994 /* Send -1 as literal "-1" to avoid host size dependency. */
12998 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13001 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13004 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
13005 result
= packet_ok (rs
->buf
,
13006 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13008 if (result
!= PACKET_OK
)
13009 warning (_("Bogus reply from target: %s"), rs
->buf
);
13014 remote_set_trace_notes (struct target_ops
*self
,
13015 const char *user
, const char *notes
,
13016 const char *stop_notes
)
13018 struct remote_state
*rs
= get_remote_state ();
13020 char *buf
= rs
->buf
;
13021 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13024 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13027 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13028 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13034 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13035 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13041 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13042 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13046 /* Ensure the buffer is terminated. */
13050 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
13051 if (*reply
== '\0')
13054 if (strcmp (reply
, "OK") != 0)
13055 error (_("Bogus reply from target: %s"), reply
);
13061 remote_use_agent (struct target_ops
*self
, int use
)
13063 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13065 struct remote_state
*rs
= get_remote_state ();
13067 /* If the stub supports QAgent. */
13068 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
13070 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13072 if (strcmp (rs
->buf
, "OK") == 0)
13083 remote_can_use_agent (struct target_ops
*self
)
13085 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13088 struct btrace_target_info
13090 /* The ptid of the traced thread. */
13093 /* The obtained branch trace configuration. */
13094 struct btrace_config conf
;
13097 /* Reset our idea of our target's btrace configuration. */
13100 remote_btrace_reset (void)
13102 struct remote_state
*rs
= get_remote_state ();
13104 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13107 /* Check whether the target supports branch tracing. */
13110 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
13112 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
13114 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
13119 case BTRACE_FORMAT_NONE
:
13122 case BTRACE_FORMAT_BTS
:
13123 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
13125 case BTRACE_FORMAT_PT
:
13126 /* The trace is decoded on the host. Even if our target supports it,
13127 we still need to have libipt to decode the trace. */
13128 #if defined (HAVE_LIBIPT)
13129 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
13130 #else /* !defined (HAVE_LIBIPT) */
13132 #endif /* !defined (HAVE_LIBIPT) */
13135 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
13138 /* Synchronize the configuration with the target. */
13141 btrace_sync_conf (const struct btrace_config
*conf
)
13143 struct packet_config
*packet
;
13144 struct remote_state
*rs
;
13145 char *buf
, *pos
, *endbuf
;
13147 rs
= get_remote_state ();
13149 endbuf
= buf
+ get_remote_packet_size ();
13151 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13152 if (packet_config_support (packet
) == PACKET_ENABLE
13153 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13156 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13160 getpkt (&buf
, &rs
->buf_size
, 0);
13162 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13164 if (buf
[0] == 'E' && buf
[1] == '.')
13165 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13167 error (_("Failed to configure the BTS buffer size."));
13170 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13173 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13174 if (packet_config_support (packet
) == PACKET_ENABLE
13175 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13178 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13182 getpkt (&buf
, &rs
->buf_size
, 0);
13184 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13186 if (buf
[0] == 'E' && buf
[1] == '.')
13187 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13189 error (_("Failed to configure the trace buffer size."));
13192 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13196 /* Read the current thread's btrace configuration from the target and
13197 store it into CONF. */
13200 btrace_read_config (struct btrace_config
*conf
)
13204 xml
= target_read_stralloc (¤t_target
,
13205 TARGET_OBJECT_BTRACE_CONF
, "");
13208 struct cleanup
*cleanup
;
13210 cleanup
= make_cleanup (xfree
, xml
);
13211 parse_xml_btrace_conf (conf
, xml
);
13212 do_cleanups (cleanup
);
13216 /* Maybe reopen target btrace. */
13219 remote_btrace_maybe_reopen (void)
13221 struct remote_state
*rs
= get_remote_state ();
13222 struct thread_info
*tp
;
13223 int btrace_target_pushed
= 0;
13226 scoped_restore_current_thread restore_thread
;
13228 ALL_NON_EXITED_THREADS (tp
)
13230 set_general_thread (tp
->ptid
);
13232 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13233 btrace_read_config (&rs
->btrace_config
);
13235 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13238 #if !defined (HAVE_LIBIPT)
13239 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13244 warning (_("GDB does not support Intel Processor Trace. "
13245 "\"record\" will not work in this session."));
13250 #endif /* !defined (HAVE_LIBIPT) */
13252 /* Push target, once, but before anything else happens. This way our
13253 changes to the threads will be cleaned up by unpushing the target
13254 in case btrace_read_config () throws. */
13255 if (!btrace_target_pushed
)
13257 btrace_target_pushed
= 1;
13258 record_btrace_push_target ();
13259 printf_filtered (_("Target is recording using %s.\n"),
13260 btrace_format_string (rs
->btrace_config
.format
));
13263 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13264 tp
->btrace
.target
->ptid
= tp
->ptid
;
13265 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13269 /* Enable branch tracing. */
13271 static struct btrace_target_info
*
13272 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
13273 const struct btrace_config
*conf
)
13275 struct btrace_target_info
*tinfo
= NULL
;
13276 struct packet_config
*packet
= NULL
;
13277 struct remote_state
*rs
= get_remote_state ();
13278 char *buf
= rs
->buf
;
13279 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13281 switch (conf
->format
)
13283 case BTRACE_FORMAT_BTS
:
13284 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13287 case BTRACE_FORMAT_PT
:
13288 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13292 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13293 error (_("Target does not support branch tracing."));
13295 btrace_sync_conf (conf
);
13297 set_general_thread (ptid
);
13299 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13301 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13303 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13305 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13306 error (_("Could not enable branch tracing for %s: %s"),
13307 target_pid_to_str (ptid
), rs
->buf
+ 2);
13309 error (_("Could not enable branch tracing for %s."),
13310 target_pid_to_str (ptid
));
13313 tinfo
= XCNEW (struct btrace_target_info
);
13314 tinfo
->ptid
= ptid
;
13316 /* If we fail to read the configuration, we lose some information, but the
13317 tracing itself is not impacted. */
13320 btrace_read_config (&tinfo
->conf
);
13322 CATCH (err
, RETURN_MASK_ERROR
)
13324 if (err
.message
!= NULL
)
13325 warning ("%s", err
.message
);
13332 /* Disable branch tracing. */
13335 remote_disable_btrace (struct target_ops
*self
,
13336 struct btrace_target_info
*tinfo
)
13338 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13339 struct remote_state
*rs
= get_remote_state ();
13340 char *buf
= rs
->buf
;
13341 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13343 if (packet_config_support (packet
) != PACKET_ENABLE
)
13344 error (_("Target does not support branch tracing."));
13346 set_general_thread (tinfo
->ptid
);
13348 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13350 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13352 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13354 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13355 error (_("Could not disable branch tracing for %s: %s"),
13356 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
13358 error (_("Could not disable branch tracing for %s."),
13359 target_pid_to_str (tinfo
->ptid
));
13365 /* Teardown branch tracing. */
13368 remote_teardown_btrace (struct target_ops
*self
,
13369 struct btrace_target_info
*tinfo
)
13371 /* We must not talk to the target during teardown. */
13375 /* Read the branch trace. */
13377 static enum btrace_error
13378 remote_read_btrace (struct target_ops
*self
,
13379 struct btrace_data
*btrace
,
13380 struct btrace_target_info
*tinfo
,
13381 enum btrace_read_type type
)
13383 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13384 struct cleanup
*cleanup
;
13388 if (packet_config_support (packet
) != PACKET_ENABLE
)
13389 error (_("Target does not support branch tracing."));
13391 #if !defined(HAVE_LIBEXPAT)
13392 error (_("Cannot process branch tracing result. XML parsing not supported."));
13397 case BTRACE_READ_ALL
:
13400 case BTRACE_READ_NEW
:
13403 case BTRACE_READ_DELTA
:
13407 internal_error (__FILE__
, __LINE__
,
13408 _("Bad branch tracing read type: %u."),
13409 (unsigned int) type
);
13412 xml
= target_read_stralloc (¤t_target
,
13413 TARGET_OBJECT_BTRACE
, annex
);
13415 return BTRACE_ERR_UNKNOWN
;
13417 cleanup
= make_cleanup (xfree
, xml
);
13418 parse_xml_btrace (btrace
, xml
);
13419 do_cleanups (cleanup
);
13421 return BTRACE_ERR_NONE
;
13424 static const struct btrace_config
*
13425 remote_btrace_conf (struct target_ops
*self
,
13426 const struct btrace_target_info
*tinfo
)
13428 return &tinfo
->conf
;
13432 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
13434 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13438 /* Implementation of to_load. */
13441 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
13443 generic_load (name
, from_tty
);
13446 /* Accepts an integer PID; returns a string representing a file that
13447 can be opened on the remote side to get the symbols for the child
13448 process. Returns NULL if the operation is not supported. */
13451 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
13453 static char *filename
= NULL
;
13454 struct inferior
*inf
;
13455 char *annex
= NULL
;
13457 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13460 if (filename
!= NULL
)
13463 inf
= find_inferior_pid (pid
);
13465 internal_error (__FILE__
, __LINE__
,
13466 _("not currently attached to process %d"), pid
);
13468 if (!inf
->fake_pid_p
)
13470 const int annex_size
= 9;
13472 annex
= (char *) alloca (annex_size
);
13473 xsnprintf (annex
, annex_size
, "%x", pid
);
13476 filename
= target_read_stralloc (¤t_target
,
13477 TARGET_OBJECT_EXEC_FILE
, annex
);
13482 /* Implement the to_can_do_single_step target_ops method. */
13485 remote_can_do_single_step (struct target_ops
*ops
)
13487 /* We can only tell whether target supports single step or not by
13488 supported s and S vCont actions if the stub supports vContSupported
13489 feature. If the stub doesn't support vContSupported feature,
13490 we have conservatively to think target doesn't supports single
13492 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13494 struct remote_state
*rs
= get_remote_state ();
13496 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13497 remote_vcont_probe (rs
);
13499 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13505 /* Implementation of the to_execution_direction method for the remote
13508 static enum exec_direction_kind
13509 remote_execution_direction (struct target_ops
*self
)
13511 struct remote_state
*rs
= get_remote_state ();
13513 return rs
->last_resume_exec_dir
;
13517 init_remote_ops (void)
13519 remote_ops
.to_shortname
= "remote";
13520 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
13521 remote_ops
.to_doc
=
13522 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13523 Specify the serial device it is connected to\n\
13524 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13525 remote_ops
.to_open
= remote_open
;
13526 remote_ops
.to_close
= remote_close
;
13527 remote_ops
.to_detach
= remote_detach
;
13528 remote_ops
.to_disconnect
= remote_disconnect
;
13529 remote_ops
.to_resume
= remote_resume
;
13530 remote_ops
.to_commit_resume
= remote_commit_resume
;
13531 remote_ops
.to_wait
= remote_wait
;
13532 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
13533 remote_ops
.to_store_registers
= remote_store_registers
;
13534 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
13535 remote_ops
.to_files_info
= remote_files_info
;
13536 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
13537 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
13538 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
13539 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
13540 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
13541 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
13542 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
13543 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
13544 remote_ops
.to_watchpoint_addr_within_range
=
13545 remote_watchpoint_addr_within_range
;
13546 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
13547 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
13548 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
13549 remote_ops
.to_region_ok_for_hw_watchpoint
13550 = remote_region_ok_for_hw_watchpoint
;
13551 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
13552 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
13553 remote_ops
.to_kill
= remote_kill
;
13554 remote_ops
.to_load
= remote_load
;
13555 remote_ops
.to_mourn_inferior
= remote_mourn
;
13556 remote_ops
.to_pass_signals
= remote_pass_signals
;
13557 remote_ops
.to_set_syscall_catchpoint
= remote_set_syscall_catchpoint
;
13558 remote_ops
.to_program_signals
= remote_program_signals
;
13559 remote_ops
.to_thread_alive
= remote_thread_alive
;
13560 remote_ops
.to_thread_name
= remote_thread_name
;
13561 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
13562 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
13563 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
13564 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
13565 remote_ops
.to_stop
= remote_stop
;
13566 remote_ops
.to_interrupt
= remote_interrupt
;
13567 remote_ops
.to_pass_ctrlc
= remote_pass_ctrlc
;
13568 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
13569 remote_ops
.to_get_memory_xfer_limit
= remote_get_memory_xfer_limit
;
13570 remote_ops
.to_rcmd
= remote_rcmd
;
13571 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
13572 remote_ops
.to_log_command
= serial_log_command
;
13573 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
13574 remote_ops
.to_stratum
= process_stratum
;
13575 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
13576 remote_ops
.to_has_memory
= default_child_has_memory
;
13577 remote_ops
.to_has_stack
= default_child_has_stack
;
13578 remote_ops
.to_has_registers
= default_child_has_registers
;
13579 remote_ops
.to_has_execution
= default_child_has_execution
;
13580 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
13581 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
13582 remote_ops
.to_magic
= OPS_MAGIC
;
13583 remote_ops
.to_memory_map
= remote_memory_map
;
13584 remote_ops
.to_flash_erase
= remote_flash_erase
;
13585 remote_ops
.to_flash_done
= remote_flash_done
;
13586 remote_ops
.to_read_description
= remote_read_description
;
13587 remote_ops
.to_search_memory
= remote_search_memory
;
13588 remote_ops
.to_can_async_p
= remote_can_async_p
;
13589 remote_ops
.to_is_async_p
= remote_is_async_p
;
13590 remote_ops
.to_async
= remote_async
;
13591 remote_ops
.to_thread_events
= remote_thread_events
;
13592 remote_ops
.to_can_do_single_step
= remote_can_do_single_step
;
13593 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
13594 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
13595 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
13596 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
13597 remote_ops
.to_supports_disable_randomization
13598 = remote_supports_disable_randomization
;
13599 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
13600 remote_ops
.to_fileio_open
= remote_hostio_open
;
13601 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
13602 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
13603 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
13604 remote_ops
.to_fileio_close
= remote_hostio_close
;
13605 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
13606 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
13607 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
13608 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
13609 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
13610 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
13611 remote_ops
.to_trace_init
= remote_trace_init
;
13612 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
13613 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
13614 remote_ops
.to_download_trace_state_variable
13615 = remote_download_trace_state_variable
;
13616 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
13617 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
13618 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
13619 remote_ops
.to_trace_start
= remote_trace_start
;
13620 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
13621 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
13622 remote_ops
.to_trace_stop
= remote_trace_stop
;
13623 remote_ops
.to_trace_find
= remote_trace_find
;
13624 remote_ops
.to_get_trace_state_variable_value
13625 = remote_get_trace_state_variable_value
;
13626 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
13627 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
13628 remote_ops
.to_upload_trace_state_variables
13629 = remote_upload_trace_state_variables
;
13630 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
13631 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
13632 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
13633 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
13634 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
13635 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
13636 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
13637 remote_ops
.to_verify_memory
= remote_verify_memory
;
13638 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
13639 remote_ops
.to_set_permissions
= remote_set_permissions
;
13640 remote_ops
.to_static_tracepoint_marker_at
13641 = remote_static_tracepoint_marker_at
;
13642 remote_ops
.to_static_tracepoint_markers_by_strid
13643 = remote_static_tracepoint_markers_by_strid
;
13644 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
13645 remote_ops
.to_use_agent
= remote_use_agent
;
13646 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
13647 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
13648 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
13649 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
13650 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
13651 remote_ops
.to_read_btrace
= remote_read_btrace
;
13652 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
13653 remote_ops
.to_augmented_libraries_svr4_read
=
13654 remote_augmented_libraries_svr4_read
;
13655 remote_ops
.to_follow_fork
= remote_follow_fork
;
13656 remote_ops
.to_follow_exec
= remote_follow_exec
;
13657 remote_ops
.to_insert_fork_catchpoint
= remote_insert_fork_catchpoint
;
13658 remote_ops
.to_remove_fork_catchpoint
= remote_remove_fork_catchpoint
;
13659 remote_ops
.to_insert_vfork_catchpoint
= remote_insert_vfork_catchpoint
;
13660 remote_ops
.to_remove_vfork_catchpoint
= remote_remove_vfork_catchpoint
;
13661 remote_ops
.to_insert_exec_catchpoint
= remote_insert_exec_catchpoint
;
13662 remote_ops
.to_remove_exec_catchpoint
= remote_remove_exec_catchpoint
;
13663 remote_ops
.to_execution_direction
= remote_execution_direction
;
13666 /* Set up the extended remote vector by making a copy of the standard
13667 remote vector and adding to it. */
13670 init_extended_remote_ops (void)
13672 extended_remote_ops
= remote_ops
;
13674 extended_remote_ops
.to_shortname
= "extended-remote";
13675 extended_remote_ops
.to_longname
=
13676 "Extended remote serial target in gdb-specific protocol";
13677 extended_remote_ops
.to_doc
=
13678 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13679 Specify the serial device it is connected to (e.g. /dev/ttya).";
13680 extended_remote_ops
.to_open
= extended_remote_open
;
13681 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
13682 extended_remote_ops
.to_detach
= extended_remote_detach
;
13683 extended_remote_ops
.to_attach
= extended_remote_attach
;
13684 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
13685 extended_remote_ops
.to_supports_disable_randomization
13686 = extended_remote_supports_disable_randomization
;
13690 remote_can_async_p (struct target_ops
*ops
)
13692 struct remote_state
*rs
= get_remote_state ();
13694 /* We don't go async if the user has explicitly prevented it with the
13695 "maint set target-async" command. */
13696 if (!target_async_permitted
)
13699 /* We're async whenever the serial device is. */
13700 return serial_can_async_p (rs
->remote_desc
);
13704 remote_is_async_p (struct target_ops
*ops
)
13706 struct remote_state
*rs
= get_remote_state ();
13708 if (!target_async_permitted
)
13709 /* We only enable async when the user specifically asks for it. */
13712 /* We're async whenever the serial device is. */
13713 return serial_is_async_p (rs
->remote_desc
);
13716 /* Pass the SERIAL event on and up to the client. One day this code
13717 will be able to delay notifying the client of an event until the
13718 point where an entire packet has been received. */
13720 static serial_event_ftype remote_async_serial_handler
;
13723 remote_async_serial_handler (struct serial
*scb
, void *context
)
13725 /* Don't propogate error information up to the client. Instead let
13726 the client find out about the error by querying the target. */
13727 inferior_event_handler (INF_REG_EVENT
, NULL
);
13731 remote_async_inferior_event_handler (gdb_client_data data
)
13733 inferior_event_handler (INF_REG_EVENT
, NULL
);
13737 remote_async (struct target_ops
*ops
, int enable
)
13739 struct remote_state
*rs
= get_remote_state ();
13743 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
13745 /* If there are pending events in the stop reply queue tell the
13746 event loop to process them. */
13747 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
13748 mark_async_event_handler (remote_async_inferior_event_token
);
13749 /* For simplicity, below we clear the pending events token
13750 without remembering whether it is marked, so here we always
13751 mark it. If there's actually no pending notification to
13752 process, this ends up being a no-op (other than a spurious
13753 event-loop wakeup). */
13754 if (target_is_non_stop_p ())
13755 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13759 serial_async (rs
->remote_desc
, NULL
, NULL
);
13760 /* If the core is disabling async, it doesn't want to be
13761 disturbed with target events. Clear all async event sources
13763 clear_async_event_handler (remote_async_inferior_event_token
);
13764 if (target_is_non_stop_p ())
13765 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13769 /* Implementation of the to_thread_events method. */
13772 remote_thread_events (struct target_ops
*ops
, int enable
)
13774 struct remote_state
*rs
= get_remote_state ();
13775 size_t size
= get_remote_packet_size ();
13777 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
13780 xsnprintf (rs
->buf
, size
, "QThreadEvents:%x", enable
? 1 : 0);
13782 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13784 switch (packet_ok (rs
->buf
,
13785 &remote_protocol_packets
[PACKET_QThreadEvents
]))
13788 if (strcmp (rs
->buf
, "OK") != 0)
13789 error (_("Remote refused setting thread events: %s"), rs
->buf
);
13792 warning (_("Remote failure reply: %s"), rs
->buf
);
13794 case PACKET_UNKNOWN
:
13800 set_remote_cmd (char *args
, int from_tty
)
13802 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
13806 show_remote_cmd (char *args
, int from_tty
)
13808 /* We can't just use cmd_show_list here, because we want to skip
13809 the redundant "show remote Z-packet" and the legacy aliases. */
13810 struct cmd_list_element
*list
= remote_show_cmdlist
;
13811 struct ui_out
*uiout
= current_uiout
;
13813 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
13814 for (; list
!= NULL
; list
= list
->next
)
13815 if (strcmp (list
->name
, "Z-packet") == 0)
13817 else if (list
->type
== not_set_cmd
)
13818 /* Alias commands are exactly like the original, except they
13819 don't have the normal type. */
13823 ui_out_emit_tuple
option_emitter (uiout
, "option");
13825 uiout
->field_string ("name", list
->name
);
13826 uiout
->text (": ");
13827 if (list
->type
== show_cmd
)
13828 do_show_command (NULL
, from_tty
, list
);
13830 cmd_func (list
, NULL
, from_tty
);
13835 /* Function to be called whenever a new objfile (shlib) is detected. */
13837 remote_new_objfile (struct objfile
*objfile
)
13839 struct remote_state
*rs
= get_remote_state ();
13841 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
13842 remote_check_symbols ();
13845 /* Pull all the tracepoints defined on the target and create local
13846 data structures representing them. We don't want to create real
13847 tracepoints yet, we don't want to mess up the user's existing
13851 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
13853 struct remote_state
*rs
= get_remote_state ();
13856 /* Ask for a first packet of tracepoint definition. */
13858 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13860 while (*p
&& *p
!= 'l')
13862 parse_tracepoint_definition (p
, utpp
);
13863 /* Ask for another packet of tracepoint definition. */
13865 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13872 remote_upload_trace_state_variables (struct target_ops
*self
,
13873 struct uploaded_tsv
**utsvp
)
13875 struct remote_state
*rs
= get_remote_state ();
13878 /* Ask for a first packet of variable definition. */
13880 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13882 while (*p
&& *p
!= 'l')
13884 parse_tsv_definition (p
, utsvp
);
13885 /* Ask for another packet of variable definition. */
13887 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13893 /* The "set/show range-stepping" show hook. */
13896 show_range_stepping (struct ui_file
*file
, int from_tty
,
13897 struct cmd_list_element
*c
,
13900 fprintf_filtered (file
,
13901 _("Debugger's willingness to use range stepping "
13902 "is %s.\n"), value
);
13905 /* The "set/show range-stepping" set hook. */
13908 set_range_stepping (char *ignore_args
, int from_tty
,
13909 struct cmd_list_element
*c
)
13911 struct remote_state
*rs
= get_remote_state ();
13913 /* Whene enabling, check whether range stepping is actually
13914 supported by the target, and warn if not. */
13915 if (use_range_stepping
)
13917 if (rs
->remote_desc
!= NULL
)
13919 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13920 remote_vcont_probe (rs
);
13922 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
13923 && rs
->supports_vCont
.r
)
13927 warning (_("Range stepping is not supported by the current target"));
13932 _initialize_remote (void)
13934 struct cmd_list_element
*cmd
;
13935 const char *cmd_name
;
13937 /* architecture specific data */
13938 remote_gdbarch_data_handle
=
13939 gdbarch_data_register_post_init (init_remote_state
);
13940 remote_g_packet_data_handle
=
13941 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
13944 = register_program_space_data_with_cleanup (NULL
,
13945 remote_pspace_data_cleanup
);
13947 /* Initialize the per-target state. At the moment there is only one
13948 of these, not one per target. Only one target is active at a
13950 remote_state
= new_remote_state ();
13952 init_remote_ops ();
13953 add_target (&remote_ops
);
13955 init_extended_remote_ops ();
13956 add_target (&extended_remote_ops
);
13958 /* Hook into new objfile notification. */
13959 observer_attach_new_objfile (remote_new_objfile
);
13960 /* We're no longer interested in notification events of an inferior
13962 observer_attach_inferior_exit (discard_pending_stop_replies
);
13965 init_remote_threadtests ();
13968 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
13969 /* set/show remote ... */
13971 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
13972 Remote protocol specific variables\n\
13973 Configure various remote-protocol specific variables such as\n\
13974 the packets being used"),
13975 &remote_set_cmdlist
, "set remote ",
13976 0 /* allow-unknown */, &setlist
);
13977 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
13978 Remote protocol specific variables\n\
13979 Configure various remote-protocol specific variables such as\n\
13980 the packets being used"),
13981 &remote_show_cmdlist
, "show remote ",
13982 0 /* allow-unknown */, &showlist
);
13984 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
13985 Compare section data on target to the exec file.\n\
13986 Argument is a single section name (default: all loaded sections).\n\
13987 To compare only read-only loaded sections, specify the -r option."),
13990 add_cmd ("packet", class_maintenance
, packet_command
, _("\
13991 Send an arbitrary packet to a remote target.\n\
13992 maintenance packet TEXT\n\
13993 If GDB is talking to an inferior via the GDB serial protocol, then\n\
13994 this command sends the string TEXT to the inferior, and displays the\n\
13995 response packet. GDB supplies the initial `$' character, and the\n\
13996 terminating `#' character and checksum."),
13999 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14000 Set whether to send break if interrupted."), _("\
14001 Show whether to send break if interrupted."), _("\
14002 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14003 set_remotebreak
, show_remotebreak
,
14004 &setlist
, &showlist
);
14005 cmd_name
= "remotebreak";
14006 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14007 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14008 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14009 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14010 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14012 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14013 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14015 Set interrupt sequence to remote target."), _("\
14016 Show interrupt sequence to remote target."), _("\
14017 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14018 NULL
, show_interrupt_sequence
,
14019 &remote_set_cmdlist
,
14020 &remote_show_cmdlist
);
14022 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14023 &interrupt_on_connect
, _("\
14024 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14025 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14026 If set, interrupt sequence is sent to remote target."),
14028 &remote_set_cmdlist
, &remote_show_cmdlist
);
14030 /* Install commands for configuring memory read/write packets. */
14032 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14033 Set the maximum number of bytes per memory write packet (deprecated)."),
14035 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14036 Show the maximum number of bytes per memory write packet (deprecated)."),
14038 add_cmd ("memory-write-packet-size", no_class
,
14039 set_memory_write_packet_size
, _("\
14040 Set the maximum number of bytes per memory-write packet.\n\
14041 Specify the number of bytes in a packet or 0 (zero) for the\n\
14042 default packet size. The actual limit is further reduced\n\
14043 dependent on the target. Specify ``fixed'' to disable the\n\
14044 further restriction and ``limit'' to enable that restriction."),
14045 &remote_set_cmdlist
);
14046 add_cmd ("memory-read-packet-size", no_class
,
14047 set_memory_read_packet_size
, _("\
14048 Set the maximum number of bytes per memory-read packet.\n\
14049 Specify the number of bytes in a packet or 0 (zero) for the\n\
14050 default packet size. The actual limit is further reduced\n\
14051 dependent on the target. Specify ``fixed'' to disable the\n\
14052 further restriction and ``limit'' to enable that restriction."),
14053 &remote_set_cmdlist
);
14054 add_cmd ("memory-write-packet-size", no_class
,
14055 show_memory_write_packet_size
,
14056 _("Show the maximum number of bytes per memory-write packet."),
14057 &remote_show_cmdlist
);
14058 add_cmd ("memory-read-packet-size", no_class
,
14059 show_memory_read_packet_size
,
14060 _("Show the maximum number of bytes per memory-read packet."),
14061 &remote_show_cmdlist
);
14063 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
14064 &remote_hw_watchpoint_limit
, _("\
14065 Set the maximum number of target hardware watchpoints."), _("\
14066 Show the maximum number of target hardware watchpoints."), _("\
14067 Specify a negative limit for unlimited."),
14068 NULL
, NULL
, /* FIXME: i18n: The maximum
14069 number of target hardware
14070 watchpoints is %s. */
14071 &remote_set_cmdlist
, &remote_show_cmdlist
);
14072 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
14073 &remote_hw_watchpoint_length_limit
, _("\
14074 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14075 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14076 Specify a negative limit for unlimited."),
14077 NULL
, NULL
, /* FIXME: i18n: The maximum
14078 length (in bytes) of a target
14079 hardware watchpoint is %s. */
14080 &remote_set_cmdlist
, &remote_show_cmdlist
);
14081 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
14082 &remote_hw_breakpoint_limit
, _("\
14083 Set the maximum number of target hardware breakpoints."), _("\
14084 Show the maximum number of target hardware breakpoints."), _("\
14085 Specify a negative limit for unlimited."),
14086 NULL
, NULL
, /* FIXME: i18n: The maximum
14087 number of target hardware
14088 breakpoints is %s. */
14089 &remote_set_cmdlist
, &remote_show_cmdlist
);
14091 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14092 &remote_address_size
, _("\
14093 Set the maximum size of the address (in bits) in a memory packet."), _("\
14094 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14096 NULL
, /* FIXME: i18n: */
14097 &setlist
, &showlist
);
14099 init_all_packet_configs ();
14101 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14102 "X", "binary-download", 1);
14104 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14105 "vCont", "verbose-resume", 0);
14107 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14108 "QPassSignals", "pass-signals", 0);
14110 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14111 "QCatchSyscalls", "catch-syscalls", 0);
14113 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14114 "QProgramSignals", "program-signals", 0);
14116 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14117 "QStartupWithShell", "startup-with-shell", 0);
14119 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14120 "qSymbol", "symbol-lookup", 0);
14122 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14123 "P", "set-register", 1);
14125 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14126 "p", "fetch-register", 1);
14128 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14129 "Z0", "software-breakpoint", 0);
14131 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14132 "Z1", "hardware-breakpoint", 0);
14134 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14135 "Z2", "write-watchpoint", 0);
14137 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14138 "Z3", "read-watchpoint", 0);
14140 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14141 "Z4", "access-watchpoint", 0);
14143 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14144 "qXfer:auxv:read", "read-aux-vector", 0);
14146 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14147 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14149 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14150 "qXfer:features:read", "target-features", 0);
14152 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14153 "qXfer:libraries:read", "library-info", 0);
14155 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14156 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14158 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14159 "qXfer:memory-map:read", "memory-map", 0);
14161 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14162 "qXfer:spu:read", "read-spu-object", 0);
14164 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14165 "qXfer:spu:write", "write-spu-object", 0);
14167 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14168 "qXfer:osdata:read", "osdata", 0);
14170 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14171 "qXfer:threads:read", "threads", 0);
14173 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14174 "qXfer:siginfo:read", "read-siginfo-object", 0);
14176 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14177 "qXfer:siginfo:write", "write-siginfo-object", 0);
14179 add_packet_config_cmd
14180 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14181 "qXfer:traceframe-info:read", "traceframe-info", 0);
14183 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14184 "qXfer:uib:read", "unwind-info-block", 0);
14186 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14187 "qGetTLSAddr", "get-thread-local-storage-address",
14190 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14191 "qGetTIBAddr", "get-thread-information-block-address",
14194 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14195 "bc", "reverse-continue", 0);
14197 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14198 "bs", "reverse-step", 0);
14200 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14201 "qSupported", "supported-packets", 0);
14203 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14204 "qSearch:memory", "search-memory", 0);
14206 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14207 "qTStatus", "trace-status", 0);
14209 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14210 "vFile:setfs", "hostio-setfs", 0);
14212 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14213 "vFile:open", "hostio-open", 0);
14215 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14216 "vFile:pread", "hostio-pread", 0);
14218 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14219 "vFile:pwrite", "hostio-pwrite", 0);
14221 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14222 "vFile:close", "hostio-close", 0);
14224 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14225 "vFile:unlink", "hostio-unlink", 0);
14227 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14228 "vFile:readlink", "hostio-readlink", 0);
14230 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14231 "vFile:fstat", "hostio-fstat", 0);
14233 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14234 "vAttach", "attach", 0);
14236 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14239 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14240 "QStartNoAckMode", "noack", 0);
14242 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14243 "vKill", "kill", 0);
14245 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14246 "qAttached", "query-attached", 0);
14248 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14249 "ConditionalTracepoints",
14250 "conditional-tracepoints", 0);
14252 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14253 "ConditionalBreakpoints",
14254 "conditional-breakpoints", 0);
14256 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14257 "BreakpointCommands",
14258 "breakpoint-commands", 0);
14260 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14261 "FastTracepoints", "fast-tracepoints", 0);
14263 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14264 "TracepointSource", "TracepointSource", 0);
14266 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14267 "QAllow", "allow", 0);
14269 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14270 "StaticTracepoints", "static-tracepoints", 0);
14272 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14273 "InstallInTrace", "install-in-trace", 0);
14275 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14276 "qXfer:statictrace:read", "read-sdata-object", 0);
14278 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14279 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14281 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14282 "QDisableRandomization", "disable-randomization", 0);
14284 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14285 "QAgent", "agent", 0);
14287 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14288 "QTBuffer:size", "trace-buffer-size", 0);
14290 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14291 "Qbtrace:off", "disable-btrace", 0);
14293 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14294 "Qbtrace:bts", "enable-btrace-bts", 0);
14296 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14297 "Qbtrace:pt", "enable-btrace-pt", 0);
14299 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14300 "qXfer:btrace", "read-btrace", 0);
14302 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14303 "qXfer:btrace-conf", "read-btrace-conf", 0);
14305 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14306 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14308 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14309 "multiprocess-feature", "multiprocess-feature", 0);
14311 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14312 "swbreak-feature", "swbreak-feature", 0);
14314 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14315 "hwbreak-feature", "hwbreak-feature", 0);
14317 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14318 "fork-event-feature", "fork-event-feature", 0);
14320 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14321 "vfork-event-feature", "vfork-event-feature", 0);
14323 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14324 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14326 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14327 "vContSupported", "verbose-resume-supported", 0);
14329 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14330 "exec-event-feature", "exec-event-feature", 0);
14332 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14333 "vCtrlC", "ctrl-c", 0);
14335 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14336 "QThreadEvents", "thread-events", 0);
14338 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14339 "N stop reply", "no-resumed-stop-reply", 0);
14341 /* Assert that we've registered "set remote foo-packet" commands
14342 for all packet configs. */
14346 for (i
= 0; i
< PACKET_MAX
; i
++)
14348 /* Ideally all configs would have a command associated. Some
14349 still don't though. */
14354 case PACKET_QNonStop
:
14355 case PACKET_EnableDisableTracepoints_feature
:
14356 case PACKET_tracenz_feature
:
14357 case PACKET_DisconnectedTracing_feature
:
14358 case PACKET_augmented_libraries_svr4_read_feature
:
14360 /* Additions to this list need to be well justified:
14361 pre-existing packets are OK; new packets are not. */
14369 /* This catches both forgetting to add a config command, and
14370 forgetting to remove a packet from the exception list. */
14371 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14375 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14376 Z sub-packet has its own set and show commands, but users may
14377 have sets to this variable in their .gdbinit files (or in their
14379 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14380 &remote_Z_packet_detect
, _("\
14381 Set use of remote protocol `Z' packets"), _("\
14382 Show use of remote protocol `Z' packets "), _("\
14383 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14385 set_remote_protocol_Z_packet_cmd
,
14386 show_remote_protocol_Z_packet_cmd
,
14387 /* FIXME: i18n: Use of remote protocol
14388 `Z' packets is %s. */
14389 &remote_set_cmdlist
, &remote_show_cmdlist
);
14391 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14392 Manipulate files on the remote system\n\
14393 Transfer files to and from the remote target system."),
14394 &remote_cmdlist
, "remote ",
14395 0 /* allow-unknown */, &cmdlist
);
14397 add_cmd ("put", class_files
, remote_put_command
,
14398 _("Copy a local file to the remote system."),
14401 add_cmd ("get", class_files
, remote_get_command
,
14402 _("Copy a remote file to the local system."),
14405 add_cmd ("delete", class_files
, remote_delete_command
,
14406 _("Delete a remote file."),
14409 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14410 &remote_exec_file_var
, _("\
14411 Set the remote pathname for \"run\""), _("\
14412 Show the remote pathname for \"run\""), NULL
,
14413 set_remote_exec_file
,
14414 show_remote_exec_file
,
14415 &remote_set_cmdlist
,
14416 &remote_show_cmdlist
);
14418 add_setshow_boolean_cmd ("range-stepping", class_run
,
14419 &use_range_stepping
, _("\
14420 Enable or disable range stepping."), _("\
14421 Show whether target-assisted range stepping is enabled."), _("\
14422 If on, and the target supports it, when stepping a source line, GDB\n\
14423 tells the target to step the corresponding range of addresses itself instead\n\
14424 of issuing multiple single-steps. This speeds up source level\n\
14425 stepping. If off, GDB always issues single-steps, even if range\n\
14426 stepping is supported by the target. The default is on."),
14427 set_range_stepping
,
14428 show_range_stepping
,
14432 /* Eventually initialize fileio. See fileio.c */
14433 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
14435 /* Take advantage of the fact that the TID field is not used, to tag
14436 special ptids with it set to != 0. */
14437 magic_null_ptid
= ptid_build (42000, -1, 1);
14438 not_sent_ptid
= ptid_build (42000, -2, 1);
14439 any_thread_ptid
= ptid_build (42000, 0, 1);
14441 target_buf_size
= 2048;
14442 target_buf
= (char *) xmalloc (target_buf_size
);