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 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
7849 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
7851 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7852 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7853 error (_("Could not write registers; remote failure reply '%s'"),
7857 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7858 of the register cache buffer. FIXME: ignores errors. */
7861 remote_store_registers (struct target_ops
*ops
,
7862 struct regcache
*regcache
, int regnum
)
7864 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7867 set_remote_traceframe ();
7868 set_general_thread (regcache_get_ptid (regcache
));
7872 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7874 gdb_assert (reg
!= NULL
);
7876 /* Always prefer to store registers using the 'P' packet if
7877 possible; we often change only a small number of registers.
7878 Sometimes we change a larger number; we'd need help from a
7879 higher layer to know to use 'G'. */
7880 if (store_register_using_P (regcache
, reg
))
7883 /* For now, don't complain if we have no way to write the
7884 register. GDB loses track of unavailable registers too
7885 easily. Some day, this may be an error. We don't have
7886 any way to read the register, either... */
7887 if (!reg
->in_g_packet
)
7890 store_registers_using_G (regcache
);
7894 store_registers_using_G (regcache
);
7896 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7897 if (!rsa
->regs
[i
].in_g_packet
)
7898 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
7899 /* See above for why we do not issue an error here. */
7904 /* Return the number of hex digits in num. */
7907 hexnumlen (ULONGEST num
)
7911 for (i
= 0; num
!= 0; i
++)
7914 return std::max (i
, 1);
7917 /* Set BUF to the minimum number of hex digits representing NUM. */
7920 hexnumstr (char *buf
, ULONGEST num
)
7922 int len
= hexnumlen (num
);
7924 return hexnumnstr (buf
, num
, len
);
7928 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7931 hexnumnstr (char *buf
, ULONGEST num
, int width
)
7937 for (i
= width
- 1; i
>= 0; i
--)
7939 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
7946 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7949 remote_address_masked (CORE_ADDR addr
)
7951 unsigned int address_size
= remote_address_size
;
7953 /* If "remoteaddresssize" was not set, default to target address size. */
7955 address_size
= gdbarch_addr_bit (target_gdbarch ());
7957 if (address_size
> 0
7958 && address_size
< (sizeof (ULONGEST
) * 8))
7960 /* Only create a mask when that mask can safely be constructed
7961 in a ULONGEST variable. */
7964 mask
= (mask
<< address_size
) - 1;
7970 /* Determine whether the remote target supports binary downloading.
7971 This is accomplished by sending a no-op memory write of zero length
7972 to the target at the specified address. It does not suffice to send
7973 the whole packet, since many stubs strip the eighth bit and
7974 subsequently compute a wrong checksum, which causes real havoc with
7977 NOTE: This can still lose if the serial line is not eight-bit
7978 clean. In cases like this, the user should clear "remote
7982 check_binary_download (CORE_ADDR addr
)
7984 struct remote_state
*rs
= get_remote_state ();
7986 switch (packet_support (PACKET_X
))
7988 case PACKET_DISABLE
:
7992 case PACKET_SUPPORT_UNKNOWN
:
7998 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8000 p
+= hexnumstr (p
, (ULONGEST
) 0);
8004 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8005 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8007 if (rs
->buf
[0] == '\0')
8010 fprintf_unfiltered (gdb_stdlog
,
8011 "binary downloading NOT "
8012 "supported by target\n");
8013 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8018 fprintf_unfiltered (gdb_stdlog
,
8019 "binary downloading supported by target\n");
8020 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8027 /* Helper function to resize the payload in order to try to get a good
8028 alignment. We try to write an amount of data such that the next write will
8029 start on an address aligned on REMOTE_ALIGN_WRITES. */
8032 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8034 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8037 /* Write memory data directly to the remote machine.
8038 This does not inform the data cache; the data cache uses this.
8039 HEADER is the starting part of the packet.
8040 MEMADDR is the address in the remote memory space.
8041 MYADDR is the address of the buffer in our space.
8042 LEN_UNITS is the number of addressable units to write.
8043 UNIT_SIZE is the length in bytes of an addressable unit.
8044 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8045 should send data as binary ('X'), or hex-encoded ('M').
8047 The function creates packet of the form
8048 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8050 where encoding of <DATA> is terminated by PACKET_FORMAT.
8052 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8055 Return the transferred status, error or OK (an
8056 'enum target_xfer_status' value). Save the number of addressable units
8057 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8059 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8060 exchange between gdb and the stub could look like (?? in place of the
8066 -> $M1000,3:eeeeffffeeee#??
8070 <- eeeeffffeeeedddd */
8072 static enum target_xfer_status
8073 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8074 const gdb_byte
*myaddr
, ULONGEST len_units
,
8075 int unit_size
, ULONGEST
*xfered_len_units
,
8076 char packet_format
, int use_length
)
8078 struct remote_state
*rs
= get_remote_state ();
8084 int payload_capacity_bytes
;
8085 int payload_length_bytes
;
8087 if (packet_format
!= 'X' && packet_format
!= 'M')
8088 internal_error (__FILE__
, __LINE__
,
8089 _("remote_write_bytes_aux: bad packet format"));
8092 return TARGET_XFER_EOF
;
8094 payload_capacity_bytes
= get_memory_write_packet_size ();
8096 /* The packet buffer will be large enough for the payload;
8097 get_memory_packet_size ensures this. */
8100 /* Compute the size of the actual payload by subtracting out the
8101 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8103 payload_capacity_bytes
-= strlen ("$,:#NN");
8105 /* The comma won't be used. */
8106 payload_capacity_bytes
+= 1;
8107 payload_capacity_bytes
-= strlen (header
);
8108 payload_capacity_bytes
-= hexnumlen (memaddr
);
8110 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8112 strcat (rs
->buf
, header
);
8113 p
= rs
->buf
+ strlen (header
);
8115 /* Compute a best guess of the number of bytes actually transfered. */
8116 if (packet_format
== 'X')
8118 /* Best guess at number of bytes that will fit. */
8119 todo_units
= std::min (len_units
,
8120 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8122 payload_capacity_bytes
-= hexnumlen (todo_units
);
8123 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8127 /* Number of bytes that will fit. */
8129 = std::min (len_units
,
8130 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8132 payload_capacity_bytes
-= hexnumlen (todo_units
);
8133 todo_units
= std::min (todo_units
,
8134 (payload_capacity_bytes
/ unit_size
) / 2);
8137 if (todo_units
<= 0)
8138 internal_error (__FILE__
, __LINE__
,
8139 _("minimum packet size too small to write data"));
8141 /* If we already need another packet, then try to align the end
8142 of this packet to a useful boundary. */
8143 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8144 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8146 /* Append "<memaddr>". */
8147 memaddr
= remote_address_masked (memaddr
);
8148 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8155 /* Append the length and retain its location and size. It may need to be
8156 adjusted once the packet body has been created. */
8158 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8166 /* Append the packet body. */
8167 if (packet_format
== 'X')
8169 /* Binary mode. Send target system values byte by byte, in
8170 increasing byte addresses. Only escape certain critical
8172 payload_length_bytes
=
8173 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8174 &units_written
, payload_capacity_bytes
);
8176 /* If not all TODO units fit, then we'll need another packet. Make
8177 a second try to keep the end of the packet aligned. Don't do
8178 this if the packet is tiny. */
8179 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8183 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8185 if (new_todo_units
!= units_written
)
8186 payload_length_bytes
=
8187 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8188 (gdb_byte
*) p
, &units_written
,
8189 payload_capacity_bytes
);
8192 p
+= payload_length_bytes
;
8193 if (use_length
&& units_written
< todo_units
)
8195 /* Escape chars have filled up the buffer prematurely,
8196 and we have actually sent fewer units than planned.
8197 Fix-up the length field of the packet. Use the same
8198 number of characters as before. */
8199 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8201 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8206 /* Normal mode: Send target system values byte by byte, in
8207 increasing byte addresses. Each byte is encoded as a two hex
8209 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8210 units_written
= todo_units
;
8213 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8214 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8216 if (rs
->buf
[0] == 'E')
8217 return TARGET_XFER_E_IO
;
8219 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8220 send fewer units than we'd planned. */
8221 *xfered_len_units
= (ULONGEST
) units_written
;
8222 return TARGET_XFER_OK
;
8225 /* Write memory data directly to the remote machine.
8226 This does not inform the data cache; the data cache uses this.
8227 MEMADDR is the address in the remote memory space.
8228 MYADDR is the address of the buffer in our space.
8229 LEN is the number of bytes.
8231 Return the transferred status, error or OK (an
8232 'enum target_xfer_status' value). Save the number of bytes
8233 transferred in *XFERED_LEN. Only transfer a single packet. */
8235 static enum target_xfer_status
8236 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
8237 int unit_size
, ULONGEST
*xfered_len
)
8239 const char *packet_format
= NULL
;
8241 /* Check whether the target supports binary download. */
8242 check_binary_download (memaddr
);
8244 switch (packet_support (PACKET_X
))
8247 packet_format
= "X";
8249 case PACKET_DISABLE
:
8250 packet_format
= "M";
8252 case PACKET_SUPPORT_UNKNOWN
:
8253 internal_error (__FILE__
, __LINE__
,
8254 _("remote_write_bytes: bad internal state"));
8256 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8259 return remote_write_bytes_aux (packet_format
,
8260 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8261 packet_format
[0], 1);
8264 /* Read memory data directly from the remote machine.
8265 This does not use the data cache; the data cache uses this.
8266 MEMADDR is the address in the remote memory space.
8267 MYADDR is the address of the buffer in our space.
8268 LEN_UNITS is the number of addressable memory units to read..
8269 UNIT_SIZE is the length in bytes of an addressable unit.
8271 Return the transferred status, error or OK (an
8272 'enum target_xfer_status' value). Save the number of bytes
8273 transferred in *XFERED_LEN_UNITS.
8275 See the comment of remote_write_bytes_aux for an example of
8276 memory read/write exchange between gdb and the stub. */
8278 static enum target_xfer_status
8279 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
8280 int unit_size
, ULONGEST
*xfered_len_units
)
8282 struct remote_state
*rs
= get_remote_state ();
8283 int buf_size_bytes
; /* Max size of packet output buffer. */
8288 buf_size_bytes
= get_memory_read_packet_size ();
8289 /* The packet buffer will be large enough for the payload;
8290 get_memory_packet_size ensures this. */
8292 /* Number of units that will fit. */
8293 todo_units
= std::min (len_units
,
8294 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8296 /* Construct "m"<memaddr>","<len>". */
8297 memaddr
= remote_address_masked (memaddr
);
8300 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8302 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8305 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8306 if (rs
->buf
[0] == 'E'
8307 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8308 && rs
->buf
[3] == '\0')
8309 return TARGET_XFER_E_IO
;
8310 /* Reply describes memory byte by byte, each byte encoded as two hex
8313 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8314 /* Return what we have. Let higher layers handle partial reads. */
8315 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8316 return TARGET_XFER_OK
;
8319 /* Using the set of read-only target sections of remote, read live
8322 For interface/parameters/return description see target.h,
8325 static enum target_xfer_status
8326 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
8327 ULONGEST memaddr
, ULONGEST len
,
8328 int unit_size
, ULONGEST
*xfered_len
)
8330 struct target_section
*secp
;
8331 struct target_section_table
*table
;
8333 secp
= target_section_by_addr (ops
, memaddr
);
8335 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8336 secp
->the_bfd_section
)
8339 struct target_section
*p
;
8340 ULONGEST memend
= memaddr
+ len
;
8342 table
= target_get_section_table (ops
);
8344 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8346 if (memaddr
>= p
->addr
)
8348 if (memend
<= p
->endaddr
)
8350 /* Entire transfer is within this section. */
8351 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8354 else if (memaddr
>= p
->endaddr
)
8356 /* This section ends before the transfer starts. */
8361 /* This section overlaps the transfer. Just do half. */
8362 len
= p
->endaddr
- memaddr
;
8363 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8370 return TARGET_XFER_EOF
;
8373 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8374 first if the requested memory is unavailable in traceframe.
8375 Otherwise, fall back to remote_read_bytes_1. */
8377 static enum target_xfer_status
8378 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
8379 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8380 ULONGEST
*xfered_len
)
8383 return TARGET_XFER_EOF
;
8385 if (get_traceframe_number () != -1)
8387 VEC(mem_range_s
) *available
;
8389 /* If we fail to get the set of available memory, then the
8390 target does not support querying traceframe info, and so we
8391 attempt reading from the traceframe anyway (assuming the
8392 target implements the old QTro packet then). */
8393 if (traceframe_available_memory (&available
, memaddr
, len
))
8395 struct cleanup
*old_chain
;
8397 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
8399 if (VEC_empty (mem_range_s
, available
)
8400 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
8402 enum target_xfer_status res
;
8404 /* Don't read into the traceframe's available
8406 if (!VEC_empty (mem_range_s
, available
))
8408 LONGEST oldlen
= len
;
8410 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
8411 gdb_assert (len
<= oldlen
);
8414 do_cleanups (old_chain
);
8416 /* This goes through the topmost target again. */
8417 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
8418 len
, unit_size
, xfered_len
);
8419 if (res
== TARGET_XFER_OK
)
8420 return TARGET_XFER_OK
;
8423 /* No use trying further, we know some memory starting
8424 at MEMADDR isn't available. */
8426 return TARGET_XFER_UNAVAILABLE
;
8430 /* Don't try to read more than how much is available, in
8431 case the target implements the deprecated QTro packet to
8432 cater for older GDBs (the target's knowledge of read-only
8433 sections may be outdated by now). */
8434 len
= VEC_index (mem_range_s
, available
, 0)->length
;
8436 do_cleanups (old_chain
);
8440 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8445 /* Sends a packet with content determined by the printf format string
8446 FORMAT and the remaining arguments, then gets the reply. Returns
8447 whether the packet was a success, a failure, or unknown. */
8449 static enum packet_result
remote_send_printf (const char *format
, ...)
8450 ATTRIBUTE_PRINTF (1, 2);
8452 static enum packet_result
8453 remote_send_printf (const char *format
, ...)
8455 struct remote_state
*rs
= get_remote_state ();
8456 int max_size
= get_remote_packet_size ();
8459 va_start (ap
, format
);
8462 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
8463 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8465 if (putpkt (rs
->buf
) < 0)
8466 error (_("Communication problem with target."));
8469 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8471 return packet_check_result (rs
->buf
);
8475 restore_remote_timeout (void *p
)
8477 int value
= *(int *)p
;
8479 remote_timeout
= value
;
8482 /* Flash writing can take quite some time. We'll set
8483 effectively infinite timeout for flash operations.
8484 In future, we'll need to decide on a better approach. */
8485 static const int remote_flash_timeout
= 1000;
8488 remote_flash_erase (struct target_ops
*ops
,
8489 ULONGEST address
, LONGEST length
)
8491 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8492 int saved_remote_timeout
= remote_timeout
;
8493 enum packet_result ret
;
8494 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8495 &saved_remote_timeout
);
8497 remote_timeout
= remote_flash_timeout
;
8499 ret
= remote_send_printf ("vFlashErase:%s,%s",
8500 phex (address
, addr_size
),
8504 case PACKET_UNKNOWN
:
8505 error (_("Remote target does not support flash erase"));
8507 error (_("Error erasing flash with vFlashErase packet"));
8512 do_cleanups (back_to
);
8515 static enum target_xfer_status
8516 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
8517 ULONGEST length
, ULONGEST
*xfered_len
,
8518 const gdb_byte
*data
)
8520 int saved_remote_timeout
= remote_timeout
;
8521 enum target_xfer_status ret
;
8522 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8523 &saved_remote_timeout
);
8525 remote_timeout
= remote_flash_timeout
;
8526 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8528 do_cleanups (back_to
);
8534 remote_flash_done (struct target_ops
*ops
)
8536 int saved_remote_timeout
= remote_timeout
;
8538 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8539 &saved_remote_timeout
);
8541 remote_timeout
= remote_flash_timeout
;
8542 ret
= remote_send_printf ("vFlashDone");
8543 do_cleanups (back_to
);
8547 case PACKET_UNKNOWN
:
8548 error (_("Remote target does not support vFlashDone"));
8550 error (_("Error finishing flash operation"));
8557 remote_files_info (struct target_ops
*ignore
)
8559 puts_filtered ("Debugging a target over a serial line.\n");
8562 /* Stuff for dealing with the packets which are part of this protocol.
8563 See comment at top of file for details. */
8565 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8566 error to higher layers. Called when a serial error is detected.
8567 The exception message is STRING, followed by a colon and a blank,
8568 the system error message for errno at function entry and final dot
8569 for output compatibility with throw_perror_with_name. */
8572 unpush_and_perror (const char *string
)
8574 int saved_errno
= errno
;
8576 remote_unpush_target ();
8577 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8578 safe_strerror (saved_errno
));
8581 /* Read a single character from the remote end. The current quit
8582 handler is overridden to avoid quitting in the middle of packet
8583 sequence, as that would break communication with the remote server.
8584 See remote_serial_quit_handler for more detail. */
8587 readchar (int timeout
)
8590 struct remote_state
*rs
= get_remote_state ();
8591 struct cleanup
*old_chain
;
8593 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8595 rs
->got_ctrlc_during_io
= 0;
8597 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8599 if (rs
->got_ctrlc_during_io
)
8602 do_cleanups (old_chain
);
8607 switch ((enum serial_rc
) ch
)
8610 remote_unpush_target ();
8611 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8614 unpush_and_perror (_("Remote communication error. "
8615 "Target disconnected."));
8617 case SERIAL_TIMEOUT
:
8623 /* Wrapper for serial_write that closes the target and throws if
8624 writing fails. The current quit handler is overridden to avoid
8625 quitting in the middle of packet sequence, as that would break
8626 communication with the remote server. See
8627 remote_serial_quit_handler for more detail. */
8630 remote_serial_write (const char *str
, int len
)
8632 struct remote_state
*rs
= get_remote_state ();
8633 struct cleanup
*old_chain
;
8635 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8637 rs
->got_ctrlc_during_io
= 0;
8639 if (serial_write (rs
->remote_desc
, str
, len
))
8641 unpush_and_perror (_("Remote communication error. "
8642 "Target disconnected."));
8645 if (rs
->got_ctrlc_during_io
)
8648 do_cleanups (old_chain
);
8651 /* Send the command in *BUF to the remote machine, and read the reply
8652 into *BUF. Report an error if we get an error reply. Resize
8653 *BUF using xrealloc if necessary to hold the result, and update
8657 remote_send (char **buf
,
8661 getpkt (buf
, sizeof_buf
, 0);
8663 if ((*buf
)[0] == 'E')
8664 error (_("Remote failure reply: %s"), *buf
);
8667 /* Return a string representing an escaped version of BUF, of len N.
8668 E.g. \n is converted to \\n, \t to \\t, etc. */
8671 escape_buffer (const char *buf
, int n
)
8675 stb
.putstrn (buf
, n
, '\\');
8676 return std::move (stb
.string ());
8679 /* Display a null-terminated packet on stdout, for debugging, using C
8683 print_packet (const char *buf
)
8685 puts_filtered ("\"");
8686 fputstr_filtered (buf
, '"', gdb_stdout
);
8687 puts_filtered ("\"");
8691 putpkt (const char *buf
)
8693 return putpkt_binary (buf
, strlen (buf
));
8696 /* Send a packet to the remote machine, with error checking. The data
8697 of the packet is in BUF. The string in BUF can be at most
8698 get_remote_packet_size () - 5 to account for the $, # and checksum,
8699 and for a possible /0 if we are debugging (remote_debug) and want
8700 to print the sent packet as a string. */
8703 putpkt_binary (const char *buf
, int cnt
)
8705 struct remote_state
*rs
= get_remote_state ();
8707 unsigned char csum
= 0;
8708 char *buf2
= (char *) xmalloc (cnt
+ 6);
8709 struct cleanup
*old_chain
= make_cleanup (xfree
, buf2
);
8715 /* Catch cases like trying to read memory or listing threads while
8716 we're waiting for a stop reply. The remote server wouldn't be
8717 ready to handle this request, so we'd hang and timeout. We don't
8718 have to worry about this in synchronous mode, because in that
8719 case it's not possible to issue a command while the target is
8720 running. This is not a problem in non-stop mode, because in that
8721 case, the stub is always ready to process serial input. */
8722 if (!target_is_non_stop_p ()
8723 && target_is_async_p ()
8724 && rs
->waiting_for_stop_reply
)
8726 error (_("Cannot execute this command while the target is running.\n"
8727 "Use the \"interrupt\" command to stop the target\n"
8728 "and then try again."));
8731 /* We're sending out a new packet. Make sure we don't look at a
8732 stale cached response. */
8733 rs
->cached_wait_status
= 0;
8735 /* Copy the packet into buffer BUF2, encapsulating it
8736 and giving it a checksum. */
8741 for (i
= 0; i
< cnt
; i
++)
8747 *p
++ = tohex ((csum
>> 4) & 0xf);
8748 *p
++ = tohex (csum
& 0xf);
8750 /* Send it over and over until we get a positive ack. */
8754 int started_error_output
= 0;
8760 int len
= (int) (p
- buf2
);
8763 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
8765 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
8767 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
8769 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
8770 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
8773 fprintf_unfiltered (gdb_stdlog
, "...");
8775 gdb_flush (gdb_stdlog
);
8777 remote_serial_write (buf2
, p
- buf2
);
8779 /* If this is a no acks version of the remote protocol, send the
8780 packet and move on. */
8784 /* Read until either a timeout occurs (-2) or '+' is read.
8785 Handle any notification that arrives in the mean time. */
8788 ch
= readchar (remote_timeout
);
8796 case SERIAL_TIMEOUT
:
8799 if (started_error_output
)
8801 putchar_unfiltered ('\n');
8802 started_error_output
= 0;
8811 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
8812 do_cleanups (old_chain
);
8816 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
8818 case SERIAL_TIMEOUT
:
8822 do_cleanups (old_chain
);
8825 break; /* Retransmit buffer. */
8829 fprintf_unfiltered (gdb_stdlog
,
8830 "Packet instead of Ack, ignoring it\n");
8831 /* It's probably an old response sent because an ACK
8832 was lost. Gobble up the packet and ack it so it
8833 doesn't get retransmitted when we resend this
8836 remote_serial_write ("+", 1);
8837 continue; /* Now, go look for +. */
8844 /* If we got a notification, handle it, and go back to looking
8846 /* We've found the start of a notification. Now
8847 collect the data. */
8848 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
8853 std::string str
= escape_buffer (rs
->buf
, val
);
8855 fprintf_unfiltered (gdb_stdlog
,
8856 " Notification received: %s\n",
8859 handle_notification (rs
->notif_state
, rs
->buf
);
8860 /* We're in sync now, rewait for the ack. */
8867 if (!started_error_output
)
8869 started_error_output
= 1;
8870 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8872 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8873 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
8882 if (!started_error_output
)
8884 started_error_output
= 1;
8885 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8887 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8891 break; /* Here to retransmit. */
8895 /* This is wrong. If doing a long backtrace, the user should be
8896 able to get out next time we call QUIT, without anything as
8897 violent as interrupt_query. If we want to provide a way out of
8898 here without getting to the next QUIT, it should be based on
8899 hitting ^C twice as in remote_wait. */
8908 do_cleanups (old_chain
);
8912 /* Come here after finding the start of a frame when we expected an
8913 ack. Do our best to discard the rest of this packet. */
8922 c
= readchar (remote_timeout
);
8925 case SERIAL_TIMEOUT
:
8926 /* Nothing we can do. */
8929 /* Discard the two bytes of checksum and stop. */
8930 c
= readchar (remote_timeout
);
8932 c
= readchar (remote_timeout
);
8935 case '*': /* Run length encoding. */
8936 /* Discard the repeat count. */
8937 c
= readchar (remote_timeout
);
8942 /* A regular character. */
8948 /* Come here after finding the start of the frame. Collect the rest
8949 into *BUF, verifying the checksum, length, and handling run-length
8950 compression. NUL terminate the buffer. If there is not enough room,
8951 expand *BUF using xrealloc.
8953 Returns -1 on error, number of characters in buffer (ignoring the
8954 trailing NULL) on success. (could be extended to return one of the
8955 SERIAL status indications). */
8958 read_frame (char **buf_p
,
8965 struct remote_state
*rs
= get_remote_state ();
8972 c
= readchar (remote_timeout
);
8975 case SERIAL_TIMEOUT
:
8977 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
8981 fputs_filtered ("Saw new packet start in middle of old one\n",
8983 return -1; /* Start a new packet, count retries. */
8986 unsigned char pktcsum
;
8992 check_0
= readchar (remote_timeout
);
8994 check_1
= readchar (remote_timeout
);
8996 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
8999 fputs_filtered ("Timeout in checksum, retrying\n",
9003 else if (check_0
< 0 || check_1
< 0)
9006 fputs_filtered ("Communication error in checksum\n",
9011 /* Don't recompute the checksum; with no ack packets we
9012 don't have any way to indicate a packet retransmission
9017 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9018 if (csum
== pktcsum
)
9023 std::string str
= escape_buffer (buf
, bc
);
9025 fprintf_unfiltered (gdb_stdlog
,
9026 "Bad checksum, sentsum=0x%x, "
9027 "csum=0x%x, buf=%s\n",
9028 pktcsum
, csum
, str
.c_str ());
9030 /* Number of characters in buffer ignoring trailing
9034 case '*': /* Run length encoding. */
9039 c
= readchar (remote_timeout
);
9041 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9043 /* The character before ``*'' is repeated. */
9045 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9047 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
9049 /* Make some more room in the buffer. */
9050 *sizeof_buf
+= repeat
;
9051 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9055 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9061 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9065 if (bc
>= *sizeof_buf
- 1)
9067 /* Make some more room in the buffer. */
9069 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9080 /* Read a packet from the remote machine, with error checking, and
9081 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9082 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9083 rather than timing out; this is used (in synchronous mode) to wait
9084 for a target that is is executing user code to stop. */
9085 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9086 don't have to change all the calls to getpkt to deal with the
9087 return value, because at the moment I don't know what the right
9088 thing to do it for those. */
9094 getpkt_sane (buf
, sizeof_buf
, forever
);
9098 /* Read a packet from the remote machine, with error checking, and
9099 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9100 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9101 rather than timing out; this is used (in synchronous mode) to wait
9102 for a target that is is executing user code to stop. If FOREVER ==
9103 0, this function is allowed to time out gracefully and return an
9104 indication of this to the caller. Otherwise return the number of
9105 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9106 enough reason to return to the caller. *IS_NOTIF is an output
9107 boolean that indicates whether *BUF holds a notification or not
9108 (a regular packet). */
9111 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
9112 int expecting_notif
, int *is_notif
)
9114 struct remote_state
*rs
= get_remote_state ();
9120 /* We're reading a new response. Make sure we don't look at a
9121 previously cached response. */
9122 rs
->cached_wait_status
= 0;
9124 strcpy (*buf
, "timeout");
9127 timeout
= watchdog
> 0 ? watchdog
: -1;
9128 else if (expecting_notif
)
9129 timeout
= 0; /* There should already be a char in the buffer. If
9132 timeout
= remote_timeout
;
9136 /* Process any number of notifications, and then return when
9140 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9142 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9144 /* This can loop forever if the remote side sends us
9145 characters continuously, but if it pauses, we'll get
9146 SERIAL_TIMEOUT from readchar because of timeout. Then
9147 we'll count that as a retry.
9149 Note that even when forever is set, we will only wait
9150 forever prior to the start of a packet. After that, we
9151 expect characters to arrive at a brisk pace. They should
9152 show up within remote_timeout intervals. */
9154 c
= readchar (timeout
);
9155 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9157 if (c
== SERIAL_TIMEOUT
)
9159 if (expecting_notif
)
9160 return -1; /* Don't complain, it's normal to not get
9161 anything in this case. */
9163 if (forever
) /* Watchdog went off? Kill the target. */
9165 remote_unpush_target ();
9166 throw_error (TARGET_CLOSE_ERROR
,
9167 _("Watchdog timeout has expired. "
9168 "Target detached."));
9171 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9175 /* We've found the start of a packet or notification.
9176 Now collect the data. */
9177 val
= read_frame (buf
, sizeof_buf
);
9182 remote_serial_write ("-", 1);
9185 if (tries
> MAX_TRIES
)
9187 /* We have tried hard enough, and just can't receive the
9188 packet/notification. Give up. */
9189 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9191 /* Skip the ack char if we're in no-ack mode. */
9192 if (!rs
->noack_mode
)
9193 remote_serial_write ("+", 1);
9197 /* If we got an ordinary packet, return that to our caller. */
9203 = escape_buffer (*buf
,
9204 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9206 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9209 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
9211 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
9212 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
9215 fprintf_unfiltered (gdb_stdlog
, "\n");
9218 /* Skip the ack char if we're in no-ack mode. */
9219 if (!rs
->noack_mode
)
9220 remote_serial_write ("+", 1);
9221 if (is_notif
!= NULL
)
9226 /* If we got a notification, handle it, and go back to looking
9230 gdb_assert (c
== '%');
9234 std::string str
= escape_buffer (*buf
, val
);
9236 fprintf_unfiltered (gdb_stdlog
,
9237 " Notification received: %s\n",
9240 if (is_notif
!= NULL
)
9243 handle_notification (rs
->notif_state
, *buf
);
9245 /* Notifications require no acknowledgement. */
9247 if (expecting_notif
)
9254 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
9256 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
9260 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
9263 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
9267 /* Check whether EVENT is a fork event for the process specified
9268 by the pid passed in DATA, and if it is, kill the fork child. */
9271 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
9272 QUEUE_ITER (stop_reply_p
) *iter
,
9276 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
9277 int parent_pid
= *(int *) param
->input
;
9279 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
9281 struct remote_state
*rs
= get_remote_state ();
9282 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
9285 res
= remote_vkill (child_pid
, rs
);
9287 error (_("Can't kill fork child process %d"), child_pid
);
9293 /* Kill any new fork children of process PID that haven't been
9294 processed by follow_fork. */
9297 kill_new_fork_children (int pid
, struct remote_state
*rs
)
9299 struct thread_info
*thread
;
9300 struct notif_client
*notif
= ¬if_client_stop
;
9301 struct queue_iter_param param
;
9303 /* Kill the fork child threads of any threads in process PID
9304 that are stopped at a fork event. */
9305 ALL_NON_EXITED_THREADS (thread
)
9307 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9309 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9311 struct remote_state
*rs
= get_remote_state ();
9312 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
9315 res
= remote_vkill (child_pid
, rs
);
9317 error (_("Can't kill fork child process %d"), child_pid
);
9321 /* Check for any pending fork events (not reported or processed yet)
9322 in process PID and kill those fork child threads as well. */
9323 remote_notif_get_pending_events (notif
);
9325 param
.output
= NULL
;
9326 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
9327 kill_child_of_pending_fork
, ¶m
);
9331 /* Target hook to kill the current inferior. */
9334 remote_kill (struct target_ops
*ops
)
9337 int pid
= ptid_get_pid (inferior_ptid
);
9338 struct remote_state
*rs
= get_remote_state ();
9340 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9342 /* If we're stopped while forking and we haven't followed yet,
9343 kill the child task. We need to do this before killing the
9344 parent task because if this is a vfork then the parent will
9346 kill_new_fork_children (pid
, rs
);
9348 res
= remote_vkill (pid
, rs
);
9351 target_mourn_inferior (inferior_ptid
);
9356 /* If we are in 'target remote' mode and we are killing the only
9357 inferior, then we will tell gdbserver to exit and unpush the
9359 if (res
== -1 && !remote_multi_process_p (rs
)
9360 && number_of_live_inferiors () == 1)
9364 /* We've killed the remote end, we get to mourn it. If we are
9365 not in extended mode, mourning the inferior also unpushes
9366 remote_ops from the target stack, which closes the remote
9368 target_mourn_inferior (inferior_ptid
);
9373 error (_("Can't kill process"));
9376 /* Send a kill request to the target using the 'vKill' packet. */
9379 remote_vkill (int pid
, struct remote_state
*rs
)
9381 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9384 /* Tell the remote target to detach. */
9385 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
9387 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9389 switch (packet_ok (rs
->buf
,
9390 &remote_protocol_packets
[PACKET_vKill
]))
9396 case PACKET_UNKNOWN
:
9399 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9403 /* Send a kill request to the target using the 'k' packet. */
9406 remote_kill_k (void)
9408 /* Catch errors so the user can quit from gdb even when we
9409 aren't on speaking terms with the remote system. */
9414 CATCH (ex
, RETURN_MASK_ERROR
)
9416 if (ex
.error
== TARGET_CLOSE_ERROR
)
9418 /* If we got an (EOF) error that caused the target
9419 to go away, then we're done, that's what we wanted.
9420 "k" is susceptible to cause a premature EOF, given
9421 that the remote server isn't actually required to
9422 reply to "k", and it can happen that it doesn't
9423 even get to reply ACK to the "k". */
9427 /* Otherwise, something went wrong. We didn't actually kill
9428 the target. Just propagate the exception, and let the
9429 user or higher layers decide what to do. */
9430 throw_exception (ex
);
9436 remote_mourn (struct target_ops
*target
)
9438 struct remote_state
*rs
= get_remote_state ();
9440 /* In 'target remote' mode with one inferior, we close the connection. */
9441 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9443 unpush_target (target
);
9445 /* remote_close takes care of doing most of the clean up. */
9446 generic_mourn_inferior ();
9450 /* In case we got here due to an error, but we're going to stay
9452 rs
->waiting_for_stop_reply
= 0;
9454 /* If the current general thread belonged to the process we just
9455 detached from or has exited, the remote side current general
9456 thread becomes undefined. Considering a case like this:
9458 - We just got here due to a detach.
9459 - The process that we're detaching from happens to immediately
9460 report a global breakpoint being hit in non-stop mode, in the
9461 same thread we had selected before.
9462 - GDB attaches to this process again.
9463 - This event happens to be the next event we handle.
9465 GDB would consider that the current general thread didn't need to
9466 be set on the stub side (with Hg), since for all it knew,
9467 GENERAL_THREAD hadn't changed.
9469 Notice that although in all-stop mode, the remote server always
9470 sets the current thread to the thread reporting the stop event,
9471 that doesn't happen in non-stop mode; in non-stop, the stub *must
9472 not* change the current thread when reporting a breakpoint hit,
9473 due to the decoupling of event reporting and event handling.
9475 To keep things simple, we always invalidate our notion of the
9477 record_currthread (rs
, minus_one_ptid
);
9479 /* Call common code to mark the inferior as not running. */
9480 generic_mourn_inferior ();
9482 if (!have_inferiors ())
9484 if (!remote_multi_process_p (rs
))
9486 /* Check whether the target is running now - some remote stubs
9487 automatically restart after kill. */
9489 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9491 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9493 /* Assume that the target has been restarted. Set
9494 inferior_ptid so that bits of core GDB realizes
9495 there's something here, e.g., so that the user can
9496 say "kill" again. */
9497 inferior_ptid
= magic_null_ptid
;
9504 extended_remote_supports_disable_randomization (struct target_ops
*self
)
9506 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9510 extended_remote_disable_randomization (int val
)
9512 struct remote_state
*rs
= get_remote_state ();
9515 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
9518 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9520 error (_("Target does not support QDisableRandomization."));
9521 if (strcmp (reply
, "OK") != 0)
9522 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9526 extended_remote_run (const std::string
&args
)
9528 struct remote_state
*rs
= get_remote_state ();
9530 const char *remote_exec_file
= get_remote_exec_file ();
9532 /* If the user has disabled vRun support, or we have detected that
9533 support is not available, do not try it. */
9534 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9537 strcpy (rs
->buf
, "vRun;");
9538 len
= strlen (rs
->buf
);
9540 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9541 error (_("Remote file name too long for run packet"));
9542 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
9543 strlen (remote_exec_file
));
9547 struct cleanup
*back_to
;
9551 argv
= gdb_buildargv (args
.c_str ());
9552 back_to
= make_cleanup_freeargv (argv
);
9553 for (i
= 0; argv
[i
] != NULL
; i
++)
9555 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9556 error (_("Argument list too long for run packet"));
9557 rs
->buf
[len
++] = ';';
9558 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
9561 do_cleanups (back_to
);
9564 rs
->buf
[len
++] = '\0';
9567 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9569 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9572 /* We have a wait response. All is well. */
9574 case PACKET_UNKNOWN
:
9577 if (remote_exec_file
[0] == '\0')
9578 error (_("Running the default executable on the remote target failed; "
9579 "try \"set remote exec-file\"?"));
9581 error (_("Running \"%s\" on the remote target failed"),
9584 gdb_assert_not_reached (_("bad switch"));
9588 /* In the extended protocol we want to be able to do things like
9589 "run" and have them basically work as expected. So we need
9590 a special create_inferior function. We support changing the
9591 executable file and the command line arguments, but not the
9595 extended_remote_create_inferior (struct target_ops
*ops
,
9596 const char *exec_file
,
9597 const std::string
&args
,
9598 char **env
, int from_tty
)
9602 struct remote_state
*rs
= get_remote_state ();
9603 const char *remote_exec_file
= get_remote_exec_file ();
9605 /* If running asynchronously, register the target file descriptor
9606 with the event loop. */
9607 if (target_can_async_p ())
9610 /* Disable address space randomization if requested (and supported). */
9611 if (extended_remote_supports_disable_randomization (ops
))
9612 extended_remote_disable_randomization (disable_randomization
);
9614 /* If startup-with-shell is on, we inform gdbserver to start the
9615 remote inferior using a shell. */
9616 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
9618 xsnprintf (rs
->buf
, get_remote_packet_size (),
9619 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
9621 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9622 if (strcmp (rs
->buf
, "OK") != 0)
9624 Remote replied unexpectedly while setting startup-with-shell: %s"),
9628 /* Now restart the remote server. */
9629 run_worked
= extended_remote_run (args
) != -1;
9632 /* vRun was not supported. Fail if we need it to do what the
9634 if (remote_exec_file
[0])
9635 error (_("Remote target does not support \"set remote exec-file\""));
9637 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9639 /* Fall back to "R". */
9640 extended_remote_restart ();
9643 if (!have_inferiors ())
9645 /* Clean up from the last time we ran, before we mark the target
9646 running again. This will mark breakpoints uninserted, and
9647 get_offsets may insert breakpoints. */
9648 init_thread_list ();
9649 init_wait_for_inferior ();
9652 /* vRun's success return is a stop reply. */
9653 stop_reply
= run_worked
? rs
->buf
: NULL
;
9654 add_current_inferior_and_thread (stop_reply
);
9656 /* Get updated offsets, if the stub uses qOffsets. */
9661 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9662 the list of conditions (in agent expression bytecode format), if any, the
9663 target needs to evaluate. The output is placed into the packet buffer
9664 started from BUF and ended at BUF_END. */
9667 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
9668 struct bp_target_info
*bp_tgt
, char *buf
,
9671 if (bp_tgt
->conditions
.empty ())
9674 buf
+= strlen (buf
);
9675 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
9678 /* Send conditions to the target. */
9679 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
9681 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
9682 buf
+= strlen (buf
);
9683 for (int i
= 0; i
< aexpr
->len
; ++i
)
9684 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9691 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
9692 struct bp_target_info
*bp_tgt
, char *buf
)
9694 if (bp_tgt
->tcommands
.empty ())
9697 buf
+= strlen (buf
);
9699 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
9700 buf
+= strlen (buf
);
9702 /* Concatenate all the agent expressions that are commands into the
9704 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
9706 sprintf (buf
, "X%x,", aexpr
->len
);
9707 buf
+= strlen (buf
);
9708 for (int i
= 0; i
< aexpr
->len
; ++i
)
9709 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9714 /* Insert a breakpoint. On targets that have software breakpoint
9715 support, we ask the remote target to do the work; on targets
9716 which don't, we insert a traditional memory breakpoint. */
9719 remote_insert_breakpoint (struct target_ops
*ops
,
9720 struct gdbarch
*gdbarch
,
9721 struct bp_target_info
*bp_tgt
)
9723 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9724 If it succeeds, then set the support to PACKET_ENABLE. If it
9725 fails, and the user has explicitly requested the Z support then
9726 report an error, otherwise, mark it disabled and go on. */
9728 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9730 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9731 struct remote_state
*rs
;
9735 /* Make sure the remote is pointing at the right process, if
9737 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9738 set_general_process ();
9740 rs
= get_remote_state ();
9742 endbuf
= rs
->buf
+ get_remote_packet_size ();
9747 addr
= (ULONGEST
) remote_address_masked (addr
);
9748 p
+= hexnumstr (p
, addr
);
9749 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9751 if (remote_supports_cond_breakpoints (ops
))
9752 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
9754 if (remote_can_run_breakpoint_commands (ops
))
9755 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
9758 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9760 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
9766 case PACKET_UNKNOWN
:
9771 /* If this breakpoint has target-side commands but this stub doesn't
9772 support Z0 packets, throw error. */
9773 if (!bp_tgt
->tcommands
.empty ())
9774 throw_error (NOT_SUPPORTED_ERROR
, _("\
9775 Target doesn't support breakpoints that have target side commands."));
9777 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
9781 remote_remove_breakpoint (struct target_ops
*ops
,
9782 struct gdbarch
*gdbarch
,
9783 struct bp_target_info
*bp_tgt
,
9784 enum remove_bp_reason reason
)
9786 CORE_ADDR addr
= bp_tgt
->placed_address
;
9787 struct remote_state
*rs
= get_remote_state ();
9789 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9792 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9794 /* Make sure the remote is pointing at the right process, if
9796 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9797 set_general_process ();
9803 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
9804 p
+= hexnumstr (p
, addr
);
9805 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9808 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9810 return (rs
->buf
[0] == 'E');
9813 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
, reason
);
9816 static enum Z_packet_type
9817 watchpoint_to_Z_packet (int type
)
9822 return Z_PACKET_WRITE_WP
;
9825 return Z_PACKET_READ_WP
;
9828 return Z_PACKET_ACCESS_WP
;
9831 internal_error (__FILE__
, __LINE__
,
9832 _("hw_bp_to_z: bad watchpoint type %d"), type
);
9837 remote_insert_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9838 enum target_hw_bp_type type
, struct expression
*cond
)
9840 struct remote_state
*rs
= get_remote_state ();
9841 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9843 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9845 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9848 /* Make sure the remote is pointing at the right process, if
9850 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9851 set_general_process ();
9853 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
9854 p
= strchr (rs
->buf
, '\0');
9855 addr
= remote_address_masked (addr
);
9856 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9857 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9860 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9862 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9866 case PACKET_UNKNOWN
:
9871 internal_error (__FILE__
, __LINE__
,
9872 _("remote_insert_watchpoint: reached end of function"));
9876 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
9877 CORE_ADDR start
, int length
)
9879 CORE_ADDR diff
= remote_address_masked (addr
- start
);
9881 return diff
< length
;
9886 remote_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9887 enum target_hw_bp_type type
, struct expression
*cond
)
9889 struct remote_state
*rs
= get_remote_state ();
9890 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9892 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9894 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9897 /* Make sure the remote is pointing at the right process, if
9899 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9900 set_general_process ();
9902 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
9903 p
= strchr (rs
->buf
, '\0');
9904 addr
= remote_address_masked (addr
);
9905 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9906 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9908 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9910 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9913 case PACKET_UNKNOWN
:
9918 internal_error (__FILE__
, __LINE__
,
9919 _("remote_remove_watchpoint: reached end of function"));
9923 int remote_hw_watchpoint_limit
= -1;
9924 int remote_hw_watchpoint_length_limit
= -1;
9925 int remote_hw_breakpoint_limit
= -1;
9928 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
9929 CORE_ADDR addr
, int len
)
9931 if (remote_hw_watchpoint_length_limit
== 0)
9933 else if (remote_hw_watchpoint_length_limit
< 0)
9935 else if (len
<= remote_hw_watchpoint_length_limit
)
9942 remote_check_watch_resources (struct target_ops
*self
,
9943 enum bptype type
, int cnt
, int ot
)
9945 if (type
== bp_hardware_breakpoint
)
9947 if (remote_hw_breakpoint_limit
== 0)
9949 else if (remote_hw_breakpoint_limit
< 0)
9951 else if (cnt
<= remote_hw_breakpoint_limit
)
9956 if (remote_hw_watchpoint_limit
== 0)
9958 else if (remote_hw_watchpoint_limit
< 0)
9962 else if (cnt
<= remote_hw_watchpoint_limit
)
9968 /* The to_stopped_by_sw_breakpoint method of target remote. */
9971 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9973 struct thread_info
*thread
= inferior_thread ();
9975 return (thread
->priv
!= NULL
9976 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
9979 /* The to_supports_stopped_by_sw_breakpoint method of target
9983 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9985 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
9988 /* The to_stopped_by_hw_breakpoint method of target remote. */
9991 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
9993 struct thread_info
*thread
= inferior_thread ();
9995 return (thread
->priv
!= NULL
9996 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
9999 /* The to_supports_stopped_by_hw_breakpoint method of target
10003 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10005 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10009 remote_stopped_by_watchpoint (struct target_ops
*ops
)
10011 struct thread_info
*thread
= inferior_thread ();
10013 return (thread
->priv
!= NULL
10014 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
);
10018 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
10020 struct thread_info
*thread
= inferior_thread ();
10022 if (thread
->priv
!= NULL
10023 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
10025 *addr_p
= thread
->priv
->watch_data_address
;
10034 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10035 struct bp_target_info
*bp_tgt
)
10037 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10038 struct remote_state
*rs
;
10042 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10045 /* Make sure the remote is pointing at the right process, if
10047 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10048 set_general_process ();
10050 rs
= get_remote_state ();
10052 endbuf
= rs
->buf
+ get_remote_packet_size ();
10058 addr
= remote_address_masked (addr
);
10059 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10060 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10062 if (remote_supports_cond_breakpoints (self
))
10063 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10065 if (remote_can_run_breakpoint_commands (self
))
10066 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10069 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10071 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10074 if (rs
->buf
[1] == '.')
10076 message
= strchr (rs
->buf
+ 2, '.');
10078 error (_("Remote failure reply: %s"), message
+ 1);
10081 case PACKET_UNKNOWN
:
10086 internal_error (__FILE__
, __LINE__
,
10087 _("remote_insert_hw_breakpoint: reached end of function"));
10092 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10093 struct bp_target_info
*bp_tgt
)
10096 struct remote_state
*rs
= get_remote_state ();
10098 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
10100 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10103 /* Make sure the remote is pointing at the right process, if
10105 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10106 set_general_process ();
10112 addr
= remote_address_masked (bp_tgt
->placed_address
);
10113 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10114 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10117 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10119 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10122 case PACKET_UNKNOWN
:
10127 internal_error (__FILE__
, __LINE__
,
10128 _("remote_remove_hw_breakpoint: reached end of function"));
10131 /* Verify memory using the "qCRC:" request. */
10134 remote_verify_memory (struct target_ops
*ops
,
10135 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10137 struct remote_state
*rs
= get_remote_state ();
10138 unsigned long host_crc
, target_crc
;
10141 /* It doesn't make sense to use qCRC if the remote target is
10142 connected but not running. */
10143 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10145 enum packet_result result
;
10147 /* Make sure the remote is pointing at the right process. */
10148 set_general_process ();
10150 /* FIXME: assumes lma can fit into long. */
10151 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
10152 (long) lma
, (long) size
);
10155 /* Be clever; compute the host_crc before waiting for target
10157 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10159 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10161 result
= packet_ok (rs
->buf
,
10162 &remote_protocol_packets
[PACKET_qCRC
]);
10163 if (result
== PACKET_ERROR
)
10165 else if (result
== PACKET_OK
)
10167 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10168 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10170 return (host_crc
== target_crc
);
10174 return simple_verify_memory (ops
, data
, lma
, size
);
10177 /* compare-sections command
10179 With no arguments, compares each loadable section in the exec bfd
10180 with the same memory range on the target, and reports mismatches.
10181 Useful for verifying the image on the target against the exec file. */
10184 compare_sections_command (char *args
, int from_tty
)
10187 struct cleanup
*old_chain
;
10188 gdb_byte
*sectdata
;
10189 const char *sectname
;
10190 bfd_size_type size
;
10193 int mismatched
= 0;
10198 error (_("command cannot be used without an exec file"));
10200 /* Make sure the remote is pointing at the right process. */
10201 set_general_process ();
10203 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10209 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10211 if (!(s
->flags
& SEC_LOAD
))
10212 continue; /* Skip non-loadable section. */
10214 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10215 continue; /* Skip writeable sections */
10217 size
= bfd_get_section_size (s
);
10219 continue; /* Skip zero-length section. */
10221 sectname
= bfd_get_section_name (exec_bfd
, s
);
10222 if (args
&& strcmp (args
, sectname
) != 0)
10223 continue; /* Not the section selected by user. */
10225 matched
= 1; /* Do this section. */
10228 sectdata
= (gdb_byte
*) xmalloc (size
);
10229 old_chain
= make_cleanup (xfree
, sectdata
);
10230 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
10232 res
= target_verify_memory (sectdata
, lma
, size
);
10235 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10236 paddress (target_gdbarch (), lma
),
10237 paddress (target_gdbarch (), lma
+ size
));
10239 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10240 paddress (target_gdbarch (), lma
),
10241 paddress (target_gdbarch (), lma
+ size
));
10243 printf_filtered ("matched.\n");
10246 printf_filtered ("MIS-MATCHED!\n");
10250 do_cleanups (old_chain
);
10252 if (mismatched
> 0)
10253 warning (_("One or more sections of the target image does not match\n\
10254 the loaded file\n"));
10255 if (args
&& !matched
)
10256 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10259 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10260 into remote target. The number of bytes written to the remote
10261 target is returned, or -1 for error. */
10263 static enum target_xfer_status
10264 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
10265 const char *annex
, const gdb_byte
*writebuf
,
10266 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
10267 struct packet_config
*packet
)
10271 struct remote_state
*rs
= get_remote_state ();
10272 int max_size
= get_memory_write_packet_size ();
10274 if (packet
->support
== PACKET_DISABLE
)
10275 return TARGET_XFER_E_IO
;
10277 /* Insert header. */
10278 i
= snprintf (rs
->buf
, max_size
,
10279 "qXfer:%s:write:%s:%s:",
10280 object_name
, annex
? annex
: "",
10281 phex_nz (offset
, sizeof offset
));
10282 max_size
-= (i
+ 1);
10284 /* Escape as much data as fits into rs->buf. */
10285 buf_len
= remote_escape_output
10286 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
10288 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
10289 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10290 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10291 return TARGET_XFER_E_IO
;
10293 unpack_varlen_hex (rs
->buf
, &n
);
10296 return TARGET_XFER_OK
;
10299 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10300 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10301 number of bytes read is returned, or 0 for EOF, or -1 for error.
10302 The number of bytes read may be less than LEN without indicating an
10303 EOF. PACKET is checked and updated to indicate whether the remote
10304 target supports this object. */
10306 static enum target_xfer_status
10307 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
10309 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
10310 ULONGEST
*xfered_len
,
10311 struct packet_config
*packet
)
10313 struct remote_state
*rs
= get_remote_state ();
10314 LONGEST i
, n
, packet_len
;
10316 if (packet
->support
== PACKET_DISABLE
)
10317 return TARGET_XFER_E_IO
;
10319 /* Check whether we've cached an end-of-object packet that matches
10321 if (rs
->finished_object
)
10323 if (strcmp (object_name
, rs
->finished_object
) == 0
10324 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10325 && offset
== rs
->finished_offset
)
10326 return TARGET_XFER_EOF
;
10329 /* Otherwise, we're now reading something different. Discard
10331 xfree (rs
->finished_object
);
10332 xfree (rs
->finished_annex
);
10333 rs
->finished_object
= NULL
;
10334 rs
->finished_annex
= NULL
;
10337 /* Request only enough to fit in a single packet. The actual data
10338 may not, since we don't know how much of it will need to be escaped;
10339 the target is free to respond with slightly less data. We subtract
10340 five to account for the response type and the protocol frame. */
10341 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10342 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10343 object_name
, annex
? annex
: "",
10344 phex_nz (offset
, sizeof offset
),
10345 phex_nz (n
, sizeof n
));
10346 i
= putpkt (rs
->buf
);
10348 return TARGET_XFER_E_IO
;
10351 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10352 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10353 return TARGET_XFER_E_IO
;
10355 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10356 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
10358 /* 'm' means there is (or at least might be) more data after this
10359 batch. That does not make sense unless there's at least one byte
10360 of data in this reply. */
10361 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10362 error (_("Remote qXfer reply contained no data."));
10364 /* Got some data. */
10365 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
10366 packet_len
- 1, readbuf
, n
);
10368 /* 'l' is an EOF marker, possibly including a final block of data,
10369 or possibly empty. If we have the final block of a non-empty
10370 object, record this fact to bypass a subsequent partial read. */
10371 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10373 rs
->finished_object
= xstrdup (object_name
);
10374 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10375 rs
->finished_offset
= offset
+ i
;
10379 return TARGET_XFER_EOF
;
10383 return TARGET_XFER_OK
;
10387 static enum target_xfer_status
10388 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
10389 const char *annex
, gdb_byte
*readbuf
,
10390 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10391 ULONGEST
*xfered_len
)
10393 struct remote_state
*rs
;
10397 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10399 set_remote_traceframe ();
10400 set_general_thread (inferior_ptid
);
10402 rs
= get_remote_state ();
10404 /* Handle memory using the standard memory routines. */
10405 if (object
== TARGET_OBJECT_MEMORY
)
10407 /* If the remote target is connected but not running, we should
10408 pass this request down to a lower stratum (e.g. the executable
10410 if (!target_has_execution
)
10411 return TARGET_XFER_EOF
;
10413 if (writebuf
!= NULL
)
10414 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10417 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
10421 /* Handle SPU memory using qxfer packets. */
10422 if (object
== TARGET_OBJECT_SPU
)
10425 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
10426 xfered_len
, &remote_protocol_packets
10427 [PACKET_qXfer_spu_read
]);
10429 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
10430 xfered_len
, &remote_protocol_packets
10431 [PACKET_qXfer_spu_write
]);
10434 /* Handle extra signal info using qxfer packets. */
10435 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10438 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
10439 xfered_len
, &remote_protocol_packets
10440 [PACKET_qXfer_siginfo_read
]);
10442 return remote_write_qxfer (ops
, "siginfo", annex
,
10443 writebuf
, offset
, len
, xfered_len
,
10444 &remote_protocol_packets
10445 [PACKET_qXfer_siginfo_write
]);
10448 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10451 return remote_read_qxfer (ops
, "statictrace", annex
,
10452 readbuf
, offset
, len
, xfered_len
,
10453 &remote_protocol_packets
10454 [PACKET_qXfer_statictrace_read
]);
10456 return TARGET_XFER_E_IO
;
10459 /* Only handle flash writes. */
10460 if (writebuf
!= NULL
)
10464 case TARGET_OBJECT_FLASH
:
10465 return remote_flash_write (ops
, offset
, len
, xfered_len
,
10469 return TARGET_XFER_E_IO
;
10473 /* Map pre-existing objects onto letters. DO NOT do this for new
10474 objects!!! Instead specify new query packets. */
10477 case TARGET_OBJECT_AVR
:
10481 case TARGET_OBJECT_AUXV
:
10482 gdb_assert (annex
== NULL
);
10483 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
10485 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10487 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10488 return remote_read_qxfer
10489 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
10490 &remote_protocol_packets
[PACKET_qXfer_features
]);
10492 case TARGET_OBJECT_LIBRARIES
:
10493 return remote_read_qxfer
10494 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10495 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10497 case TARGET_OBJECT_LIBRARIES_SVR4
:
10498 return remote_read_qxfer
10499 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10500 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10502 case TARGET_OBJECT_MEMORY_MAP
:
10503 gdb_assert (annex
== NULL
);
10504 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
10506 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10508 case TARGET_OBJECT_OSDATA
:
10509 /* Should only get here if we're connected. */
10510 gdb_assert (rs
->remote_desc
);
10511 return remote_read_qxfer
10512 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10513 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10515 case TARGET_OBJECT_THREADS
:
10516 gdb_assert (annex
== NULL
);
10517 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
10519 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10521 case TARGET_OBJECT_TRACEFRAME_INFO
:
10522 gdb_assert (annex
== NULL
);
10523 return remote_read_qxfer
10524 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10525 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10527 case TARGET_OBJECT_FDPIC
:
10528 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
10530 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10532 case TARGET_OBJECT_OPENVMS_UIB
:
10533 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
10535 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10537 case TARGET_OBJECT_BTRACE
:
10538 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
10540 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10542 case TARGET_OBJECT_BTRACE_CONF
:
10543 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
10545 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10547 case TARGET_OBJECT_EXEC_FILE
:
10548 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
10550 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10553 return TARGET_XFER_E_IO
;
10556 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10557 large enough let the caller deal with it. */
10558 if (len
< get_remote_packet_size ())
10559 return TARGET_XFER_E_IO
;
10560 len
= get_remote_packet_size ();
10562 /* Except for querying the minimum buffer size, target must be open. */
10563 if (!rs
->remote_desc
)
10564 error (_("remote query is only available after target open"));
10566 gdb_assert (annex
!= NULL
);
10567 gdb_assert (readbuf
!= NULL
);
10571 *p2
++ = query_type
;
10573 /* We used one buffer char for the remote protocol q command and
10574 another for the query type. As the remote protocol encapsulation
10575 uses 4 chars plus one extra in case we are debugging
10576 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10579 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10581 /* Bad caller may have sent forbidden characters. */
10582 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10587 gdb_assert (annex
[i
] == '\0');
10589 i
= putpkt (rs
->buf
);
10591 return TARGET_XFER_E_IO
;
10593 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10594 strcpy ((char *) readbuf
, rs
->buf
);
10596 *xfered_len
= strlen ((char *) readbuf
);
10597 return TARGET_XFER_OK
;
10600 /* Implementation of to_get_memory_xfer_limit. */
10603 remote_get_memory_xfer_limit (struct target_ops
*ops
)
10605 return get_memory_write_packet_size ();
10609 remote_search_memory (struct target_ops
* ops
,
10610 CORE_ADDR start_addr
, ULONGEST search_space_len
,
10611 const gdb_byte
*pattern
, ULONGEST pattern_len
,
10612 CORE_ADDR
*found_addrp
)
10614 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
10615 struct remote_state
*rs
= get_remote_state ();
10616 int max_size
= get_memory_write_packet_size ();
10617 struct packet_config
*packet
=
10618 &remote_protocol_packets
[PACKET_qSearch_memory
];
10619 /* Number of packet bytes used to encode the pattern;
10620 this could be more than PATTERN_LEN due to escape characters. */
10621 int escaped_pattern_len
;
10622 /* Amount of pattern that was encodable in the packet. */
10623 int used_pattern_len
;
10626 ULONGEST found_addr
;
10628 /* Don't go to the target if we don't have to.
10629 This is done before checking packet->support to avoid the possibility that
10630 a success for this edge case means the facility works in general. */
10631 if (pattern_len
> search_space_len
)
10633 if (pattern_len
== 0)
10635 *found_addrp
= start_addr
;
10639 /* If we already know the packet isn't supported, fall back to the simple
10640 way of searching memory. */
10642 if (packet_config_support (packet
) == PACKET_DISABLE
)
10644 /* Target doesn't provided special support, fall back and use the
10645 standard support (copy memory and do the search here). */
10646 return simple_search_memory (ops
, start_addr
, search_space_len
,
10647 pattern
, pattern_len
, found_addrp
);
10650 /* Make sure the remote is pointing at the right process. */
10651 set_general_process ();
10653 /* Insert header. */
10654 i
= snprintf (rs
->buf
, max_size
,
10655 "qSearch:memory:%s;%s;",
10656 phex_nz (start_addr
, addr_size
),
10657 phex_nz (search_space_len
, sizeof (search_space_len
)));
10658 max_size
-= (i
+ 1);
10660 /* Escape as much data as fits into rs->buf. */
10661 escaped_pattern_len
=
10662 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
10663 &used_pattern_len
, max_size
);
10665 /* Bail if the pattern is too large. */
10666 if (used_pattern_len
!= pattern_len
)
10667 error (_("Pattern is too large to transmit to remote target."));
10669 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
10670 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10671 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10673 /* The request may not have worked because the command is not
10674 supported. If so, fall back to the simple way. */
10675 if (packet
->support
== PACKET_DISABLE
)
10677 return simple_search_memory (ops
, start_addr
, search_space_len
,
10678 pattern
, pattern_len
, found_addrp
);
10683 if (rs
->buf
[0] == '0')
10685 else if (rs
->buf
[0] == '1')
10688 if (rs
->buf
[1] != ',')
10689 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10690 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
10691 *found_addrp
= found_addr
;
10694 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10700 remote_rcmd (struct target_ops
*self
, const char *command
,
10701 struct ui_file
*outbuf
)
10703 struct remote_state
*rs
= get_remote_state ();
10706 if (!rs
->remote_desc
)
10707 error (_("remote rcmd is only available after target open"));
10709 /* Send a NULL command across as an empty command. */
10710 if (command
== NULL
)
10713 /* The query prefix. */
10714 strcpy (rs
->buf
, "qRcmd,");
10715 p
= strchr (rs
->buf
, '\0');
10717 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
10718 > get_remote_packet_size ())
10719 error (_("\"monitor\" command ``%s'' is too long."), command
);
10721 /* Encode the actual command. */
10722 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
10724 if (putpkt (rs
->buf
) < 0)
10725 error (_("Communication problem with target."));
10727 /* get/display the response */
10732 /* XXX - see also remote_get_noisy_reply(). */
10733 QUIT
; /* Allow user to bail out with ^C. */
10735 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
10737 /* Timeout. Continue to (try to) read responses.
10738 This is better than stopping with an error, assuming the stub
10739 is still executing the (long) monitor command.
10740 If needed, the user can interrupt gdb using C-c, obtaining
10741 an effect similar to stop on timeout. */
10745 if (buf
[0] == '\0')
10746 error (_("Target does not support this command."));
10747 if (buf
[0] == 'O' && buf
[1] != 'K')
10749 remote_console_output (buf
+ 1); /* 'O' message from stub. */
10752 if (strcmp (buf
, "OK") == 0)
10754 if (strlen (buf
) == 3 && buf
[0] == 'E'
10755 && isdigit (buf
[1]) && isdigit (buf
[2]))
10757 error (_("Protocol error with Rcmd"));
10759 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
10761 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
10763 fputc_unfiltered (c
, outbuf
);
10769 static VEC(mem_region_s
) *
10770 remote_memory_map (struct target_ops
*ops
)
10772 VEC(mem_region_s
) *result
= NULL
;
10773 char *text
= target_read_stralloc (¤t_target
,
10774 TARGET_OBJECT_MEMORY_MAP
, NULL
);
10778 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
10780 result
= parse_memory_map (text
);
10781 do_cleanups (back_to
);
10788 packet_command (char *args
, int from_tty
)
10790 struct remote_state
*rs
= get_remote_state ();
10792 if (!rs
->remote_desc
)
10793 error (_("command can only be used with remote target"));
10796 error (_("remote-packet command requires packet text as argument"));
10798 puts_filtered ("sending: ");
10799 print_packet (args
);
10800 puts_filtered ("\n");
10803 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10804 puts_filtered ("received: ");
10805 print_packet (rs
->buf
);
10806 puts_filtered ("\n");
10810 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10812 static void display_thread_info (struct gdb_ext_thread_info
*info
);
10814 static void threadset_test_cmd (char *cmd
, int tty
);
10816 static void threadalive_test (char *cmd
, int tty
);
10818 static void threadlist_test_cmd (char *cmd
, int tty
);
10820 int get_and_display_threadinfo (threadref
*ref
);
10822 static void threadinfo_test_cmd (char *cmd
, int tty
);
10824 static int thread_display_step (threadref
*ref
, void *context
);
10826 static void threadlist_update_test_cmd (char *cmd
, int tty
);
10828 static void init_remote_threadtests (void);
10830 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10833 threadset_test_cmd (char *cmd
, int tty
)
10835 int sample_thread
= SAMPLE_THREAD
;
10837 printf_filtered (_("Remote threadset test\n"));
10838 set_general_thread (sample_thread
);
10843 threadalive_test (char *cmd
, int tty
)
10845 int sample_thread
= SAMPLE_THREAD
;
10846 int pid
= ptid_get_pid (inferior_ptid
);
10847 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
10849 if (remote_thread_alive (ptid
))
10850 printf_filtered ("PASS: Thread alive test\n");
10852 printf_filtered ("FAIL: Thread alive test\n");
10855 void output_threadid (char *title
, threadref
*ref
);
10858 output_threadid (char *title
, threadref
*ref
)
10862 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
10864 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
10868 threadlist_test_cmd (char *cmd
, int tty
)
10871 threadref nextthread
;
10872 int done
, result_count
;
10873 threadref threadlist
[3];
10875 printf_filtered ("Remote Threadlist test\n");
10876 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
10877 &result_count
, &threadlist
[0]))
10878 printf_filtered ("FAIL: threadlist test\n");
10881 threadref
*scan
= threadlist
;
10882 threadref
*limit
= scan
+ result_count
;
10884 while (scan
< limit
)
10885 output_threadid (" thread ", scan
++);
10890 display_thread_info (struct gdb_ext_thread_info
*info
)
10892 output_threadid ("Threadid: ", &info
->threadid
);
10893 printf_filtered ("Name: %s\n ", info
->shortname
);
10894 printf_filtered ("State: %s\n", info
->display
);
10895 printf_filtered ("other: %s\n\n", info
->more_display
);
10899 get_and_display_threadinfo (threadref
*ref
)
10903 struct gdb_ext_thread_info threadinfo
;
10905 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
10906 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
10907 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
10908 display_thread_info (&threadinfo
);
10913 threadinfo_test_cmd (char *cmd
, int tty
)
10915 int athread
= SAMPLE_THREAD
;
10919 int_to_threadref (&thread
, athread
);
10920 printf_filtered ("Remote Threadinfo test\n");
10921 if (!get_and_display_threadinfo (&thread
))
10922 printf_filtered ("FAIL cannot get thread info\n");
10926 thread_display_step (threadref
*ref
, void *context
)
10928 /* output_threadid(" threadstep ",ref); *//* simple test */
10929 return get_and_display_threadinfo (ref
);
10933 threadlist_update_test_cmd (char *cmd
, int tty
)
10935 printf_filtered ("Remote Threadlist update test\n");
10936 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
10940 init_remote_threadtests (void)
10942 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
10943 _("Fetch and print the remote list of "
10944 "thread identifiers, one pkt only"));
10945 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
10946 _("Fetch and display info about one thread"));
10947 add_com ("tset", class_obscure
, threadset_test_cmd
,
10948 _("Test setting to a different thread"));
10949 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
10950 _("Iterate through updating all remote thread info"));
10951 add_com ("talive", class_obscure
, threadalive_test
,
10952 _(" Remote thread alive test "));
10957 /* Convert a thread ID to a string. Returns the string in a static
10960 static const char *
10961 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
10963 static char buf
[64];
10964 struct remote_state
*rs
= get_remote_state ();
10966 if (ptid_equal (ptid
, null_ptid
))
10967 return normal_pid_to_str (ptid
);
10968 else if (ptid_is_pid (ptid
))
10970 /* Printing an inferior target id. */
10972 /* When multi-process extensions are off, there's no way in the
10973 remote protocol to know the remote process id, if there's any
10974 at all. There's one exception --- when we're connected with
10975 target extended-remote, and we manually attached to a process
10976 with "attach PID". We don't record anywhere a flag that
10977 allows us to distinguish that case from the case of
10978 connecting with extended-remote and the stub already being
10979 attached to a process, and reporting yes to qAttached, hence
10980 no smart special casing here. */
10981 if (!remote_multi_process_p (rs
))
10983 xsnprintf (buf
, sizeof buf
, "Remote target");
10987 return normal_pid_to_str (ptid
);
10991 if (ptid_equal (magic_null_ptid
, ptid
))
10992 xsnprintf (buf
, sizeof buf
, "Thread <main>");
10993 else if (remote_multi_process_p (rs
))
10994 if (ptid_get_lwp (ptid
) == 0)
10995 return normal_pid_to_str (ptid
);
10997 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
10998 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
11000 xsnprintf (buf
, sizeof buf
, "Thread %ld",
11001 ptid_get_lwp (ptid
));
11006 /* Get the address of the thread local variable in OBJFILE which is
11007 stored at OFFSET within the thread local storage for thread PTID. */
11010 remote_get_thread_local_address (struct target_ops
*ops
,
11011 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
11013 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11015 struct remote_state
*rs
= get_remote_state ();
11017 char *endp
= rs
->buf
+ get_remote_packet_size ();
11018 enum packet_result result
;
11020 strcpy (p
, "qGetTLSAddr:");
11022 p
= write_ptid (p
, endp
, ptid
);
11024 p
+= hexnumstr (p
, offset
);
11026 p
+= hexnumstr (p
, lm
);
11030 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11031 result
= packet_ok (rs
->buf
,
11032 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11033 if (result
== PACKET_OK
)
11037 unpack_varlen_hex (rs
->buf
, &result
);
11040 else if (result
== PACKET_UNKNOWN
)
11041 throw_error (TLS_GENERIC_ERROR
,
11042 _("Remote target doesn't support qGetTLSAddr packet"));
11044 throw_error (TLS_GENERIC_ERROR
,
11045 _("Remote target failed to process qGetTLSAddr request"));
11048 throw_error (TLS_GENERIC_ERROR
,
11049 _("TLS not supported or disabled on this target"));
11054 /* Provide thread local base, i.e. Thread Information Block address.
11055 Returns 1 if ptid is found and thread_local_base is non zero. */
11058 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
11060 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11062 struct remote_state
*rs
= get_remote_state ();
11064 char *endp
= rs
->buf
+ get_remote_packet_size ();
11065 enum packet_result result
;
11067 strcpy (p
, "qGetTIBAddr:");
11069 p
= write_ptid (p
, endp
, ptid
);
11073 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11074 result
= packet_ok (rs
->buf
,
11075 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11076 if (result
== PACKET_OK
)
11080 unpack_varlen_hex (rs
->buf
, &result
);
11082 *addr
= (CORE_ADDR
) result
;
11085 else if (result
== PACKET_UNKNOWN
)
11086 error (_("Remote target doesn't support qGetTIBAddr packet"));
11088 error (_("Remote target failed to process qGetTIBAddr request"));
11091 error (_("qGetTIBAddr not supported or disabled on this target"));
11096 /* Support for inferring a target description based on the current
11097 architecture and the size of a 'g' packet. While the 'g' packet
11098 can have any size (since optional registers can be left off the
11099 end), some sizes are easily recognizable given knowledge of the
11100 approximate architecture. */
11102 struct remote_g_packet_guess
11105 const struct target_desc
*tdesc
;
11107 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
11108 DEF_VEC_O(remote_g_packet_guess_s
);
11110 struct remote_g_packet_data
11112 VEC(remote_g_packet_guess_s
) *guesses
;
11115 static struct gdbarch_data
*remote_g_packet_data_handle
;
11118 remote_g_packet_data_init (struct obstack
*obstack
)
11120 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
11124 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11125 const struct target_desc
*tdesc
)
11127 struct remote_g_packet_data
*data
11128 = ((struct remote_g_packet_data
*)
11129 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11130 struct remote_g_packet_guess new_guess
, *guess
;
11133 gdb_assert (tdesc
!= NULL
);
11136 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11138 if (guess
->bytes
== bytes
)
11139 internal_error (__FILE__
, __LINE__
,
11140 _("Duplicate g packet description added for size %d"),
11143 new_guess
.bytes
= bytes
;
11144 new_guess
.tdesc
= tdesc
;
11145 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
11148 /* Return 1 if remote_read_description would do anything on this target
11149 and architecture, 0 otherwise. */
11152 remote_read_description_p (struct target_ops
*target
)
11154 struct remote_g_packet_data
*data
11155 = ((struct remote_g_packet_data
*)
11156 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11158 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11164 static const struct target_desc
*
11165 remote_read_description (struct target_ops
*target
)
11167 struct remote_g_packet_data
*data
11168 = ((struct remote_g_packet_data
*)
11169 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11171 /* Do not try this during initial connection, when we do not know
11172 whether there is a running but stopped thread. */
11173 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
11174 return target
->beneath
->to_read_description (target
->beneath
);
11176 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11178 struct remote_g_packet_guess
*guess
;
11180 int bytes
= send_g_packet ();
11183 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11185 if (guess
->bytes
== bytes
)
11186 return guess
->tdesc
;
11188 /* We discard the g packet. A minor optimization would be to
11189 hold on to it, and fill the register cache once we have selected
11190 an architecture, but it's too tricky to do safely. */
11193 return target
->beneath
->to_read_description (target
->beneath
);
11196 /* Remote file transfer support. This is host-initiated I/O, not
11197 target-initiated; for target-initiated, see remote-fileio.c. */
11199 /* If *LEFT is at least the length of STRING, copy STRING to
11200 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11201 decrease *LEFT. Otherwise raise an error. */
11204 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11206 int len
= strlen (string
);
11209 error (_("Packet too long for target."));
11211 memcpy (*buffer
, string
, len
);
11215 /* NUL-terminate the buffer as a convenience, if there is
11221 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11222 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11223 decrease *LEFT. Otherwise raise an error. */
11226 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11229 if (2 * len
> *left
)
11230 error (_("Packet too long for target."));
11232 bin2hex (bytes
, *buffer
, len
);
11233 *buffer
+= 2 * len
;
11236 /* NUL-terminate the buffer as a convenience, if there is
11242 /* If *LEFT is large enough, convert VALUE to hex and add it to
11243 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11244 decrease *LEFT. Otherwise raise an error. */
11247 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11249 int len
= hexnumlen (value
);
11252 error (_("Packet too long for target."));
11254 hexnumstr (*buffer
, value
);
11258 /* NUL-terminate the buffer as a convenience, if there is
11264 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11265 value, *REMOTE_ERRNO to the remote error number or zero if none
11266 was included, and *ATTACHMENT to point to the start of the annex
11267 if any. The length of the packet isn't needed here; there may
11268 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11270 Return 0 if the packet could be parsed, -1 if it could not. If
11271 -1 is returned, the other variables may not be initialized. */
11274 remote_hostio_parse_result (char *buffer
, int *retcode
,
11275 int *remote_errno
, char **attachment
)
11280 *attachment
= NULL
;
11282 if (buffer
[0] != 'F')
11286 *retcode
= strtol (&buffer
[1], &p
, 16);
11287 if (errno
!= 0 || p
== &buffer
[1])
11290 /* Check for ",errno". */
11294 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11295 if (errno
!= 0 || p
+ 1 == p2
)
11300 /* Check for ";attachment". If there is no attachment, the
11301 packet should end here. */
11304 *attachment
= p
+ 1;
11307 else if (*p
== '\0')
11313 /* Send a prepared I/O packet to the target and read its response.
11314 The prepared packet is in the global RS->BUF before this function
11315 is called, and the answer is there when we return.
11317 COMMAND_BYTES is the length of the request to send, which may include
11318 binary data. WHICH_PACKET is the packet configuration to check
11319 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11320 is set to the error number and -1 is returned. Otherwise the value
11321 returned by the function is returned.
11323 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11324 attachment is expected; an error will be reported if there's a
11325 mismatch. If one is found, *ATTACHMENT will be set to point into
11326 the packet buffer and *ATTACHMENT_LEN will be set to the
11327 attachment's length. */
11330 remote_hostio_send_command (int command_bytes
, int which_packet
,
11331 int *remote_errno
, char **attachment
,
11332 int *attachment_len
)
11334 struct remote_state
*rs
= get_remote_state ();
11335 int ret
, bytes_read
;
11336 char *attachment_tmp
;
11338 if (!rs
->remote_desc
11339 || packet_support (which_packet
) == PACKET_DISABLE
)
11341 *remote_errno
= FILEIO_ENOSYS
;
11345 putpkt_binary (rs
->buf
, command_bytes
);
11346 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
11348 /* If it timed out, something is wrong. Don't try to parse the
11350 if (bytes_read
< 0)
11352 *remote_errno
= FILEIO_EINVAL
;
11356 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11359 *remote_errno
= FILEIO_EINVAL
;
11361 case PACKET_UNKNOWN
:
11362 *remote_errno
= FILEIO_ENOSYS
;
11368 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
11371 *remote_errno
= FILEIO_EINVAL
;
11375 /* Make sure we saw an attachment if and only if we expected one. */
11376 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11377 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11379 *remote_errno
= FILEIO_EINVAL
;
11383 /* If an attachment was found, it must point into the packet buffer;
11384 work out how many bytes there were. */
11385 if (attachment_tmp
!= NULL
)
11387 *attachment
= attachment_tmp
;
11388 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
11394 /* Invalidate the readahead cache. */
11397 readahead_cache_invalidate (void)
11399 struct remote_state
*rs
= get_remote_state ();
11401 rs
->readahead_cache
.fd
= -1;
11404 /* Invalidate the readahead cache if it is holding data for FD. */
11407 readahead_cache_invalidate_fd (int fd
)
11409 struct remote_state
*rs
= get_remote_state ();
11411 if (rs
->readahead_cache
.fd
== fd
)
11412 rs
->readahead_cache
.fd
= -1;
11415 /* Set the filesystem remote_hostio functions that take FILENAME
11416 arguments will use. Return 0 on success, or -1 if an error
11417 occurs (and set *REMOTE_ERRNO). */
11420 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
11422 struct remote_state
*rs
= get_remote_state ();
11423 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11425 int left
= get_remote_packet_size () - 1;
11429 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11432 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11435 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11437 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11438 remote_buffer_add_string (&p
, &left
, arg
);
11440 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
11441 remote_errno
, NULL
, NULL
);
11443 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11447 rs
->fs_pid
= required_pid
;
11452 /* Implementation of to_fileio_open. */
11455 remote_hostio_open (struct target_ops
*self
,
11456 struct inferior
*inf
, const char *filename
,
11457 int flags
, int mode
, int warn_if_slow
,
11460 struct remote_state
*rs
= get_remote_state ();
11462 int left
= get_remote_packet_size () - 1;
11466 static int warning_issued
= 0;
11468 printf_unfiltered (_("Reading %s from remote target...\n"),
11471 if (!warning_issued
)
11473 warning (_("File transfers from remote targets can be slow."
11474 " Use \"set sysroot\" to access files locally"
11476 warning_issued
= 1;
11480 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11483 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11485 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11486 strlen (filename
));
11487 remote_buffer_add_string (&p
, &left
, ",");
11489 remote_buffer_add_int (&p
, &left
, flags
);
11490 remote_buffer_add_string (&p
, &left
, ",");
11492 remote_buffer_add_int (&p
, &left
, mode
);
11494 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
11495 remote_errno
, NULL
, NULL
);
11498 /* Implementation of to_fileio_pwrite. */
11501 remote_hostio_pwrite (struct target_ops
*self
,
11502 int fd
, const gdb_byte
*write_buf
, int len
,
11503 ULONGEST offset
, int *remote_errno
)
11505 struct remote_state
*rs
= get_remote_state ();
11507 int left
= get_remote_packet_size ();
11510 readahead_cache_invalidate_fd (fd
);
11512 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11514 remote_buffer_add_int (&p
, &left
, fd
);
11515 remote_buffer_add_string (&p
, &left
, ",");
11517 remote_buffer_add_int (&p
, &left
, offset
);
11518 remote_buffer_add_string (&p
, &left
, ",");
11520 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11521 get_remote_packet_size () - (p
- rs
->buf
));
11523 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
11524 remote_errno
, NULL
, NULL
);
11527 /* Helper for the implementation of to_fileio_pread. Read the file
11528 from the remote side with vFile:pread. */
11531 remote_hostio_pread_vFile (struct target_ops
*self
,
11532 int fd
, gdb_byte
*read_buf
, int len
,
11533 ULONGEST offset
, int *remote_errno
)
11535 struct remote_state
*rs
= get_remote_state ();
11538 int left
= get_remote_packet_size ();
11539 int ret
, attachment_len
;
11542 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11544 remote_buffer_add_int (&p
, &left
, fd
);
11545 remote_buffer_add_string (&p
, &left
, ",");
11547 remote_buffer_add_int (&p
, &left
, len
);
11548 remote_buffer_add_string (&p
, &left
, ",");
11550 remote_buffer_add_int (&p
, &left
, offset
);
11552 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
11553 remote_errno
, &attachment
,
11559 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11561 if (read_len
!= ret
)
11562 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11567 /* Serve pread from the readahead cache. Returns number of bytes
11568 read, or 0 if the request can't be served from the cache. */
11571 remote_hostio_pread_from_cache (struct remote_state
*rs
,
11572 int fd
, gdb_byte
*read_buf
, size_t len
,
11575 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11577 if (cache
->fd
== fd
11578 && cache
->offset
<= offset
11579 && offset
< cache
->offset
+ cache
->bufsize
)
11581 ULONGEST max
= cache
->offset
+ cache
->bufsize
;
11583 if (offset
+ len
> max
)
11584 len
= max
- offset
;
11586 memcpy (read_buf
, cache
->buf
+ offset
- cache
->offset
, len
);
11593 /* Implementation of to_fileio_pread. */
11596 remote_hostio_pread (struct target_ops
*self
,
11597 int fd
, gdb_byte
*read_buf
, int len
,
11598 ULONGEST offset
, int *remote_errno
)
11601 struct remote_state
*rs
= get_remote_state ();
11602 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11604 ret
= remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11607 cache
->hit_count
++;
11610 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
11611 pulongest (cache
->hit_count
));
11615 cache
->miss_count
++;
11617 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
11618 pulongest (cache
->miss_count
));
11621 cache
->offset
= offset
;
11622 cache
->bufsize
= get_remote_packet_size ();
11623 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
11625 ret
= remote_hostio_pread_vFile (self
, cache
->fd
, cache
->buf
, cache
->bufsize
,
11626 cache
->offset
, remote_errno
);
11629 readahead_cache_invalidate_fd (fd
);
11633 cache
->bufsize
= ret
;
11634 return remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11637 /* Implementation of to_fileio_close. */
11640 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
11642 struct remote_state
*rs
= get_remote_state ();
11644 int left
= get_remote_packet_size () - 1;
11646 readahead_cache_invalidate_fd (fd
);
11648 remote_buffer_add_string (&p
, &left
, "vFile:close:");
11650 remote_buffer_add_int (&p
, &left
, fd
);
11652 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
11653 remote_errno
, NULL
, NULL
);
11656 /* Implementation of to_fileio_unlink. */
11659 remote_hostio_unlink (struct target_ops
*self
,
11660 struct inferior
*inf
, const char *filename
,
11663 struct remote_state
*rs
= get_remote_state ();
11665 int left
= get_remote_packet_size () - 1;
11667 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11670 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
11672 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11673 strlen (filename
));
11675 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
11676 remote_errno
, NULL
, NULL
);
11679 /* Implementation of to_fileio_readlink. */
11682 remote_hostio_readlink (struct target_ops
*self
,
11683 struct inferior
*inf
, const char *filename
,
11686 struct remote_state
*rs
= get_remote_state ();
11689 int left
= get_remote_packet_size ();
11690 int len
, attachment_len
;
11694 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11697 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
11699 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11700 strlen (filename
));
11702 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
11703 remote_errno
, &attachment
,
11709 ret
= (char *) xmalloc (len
+ 1);
11711 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11712 (gdb_byte
*) ret
, len
);
11713 if (read_len
!= len
)
11714 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
11720 /* Implementation of to_fileio_fstat. */
11723 remote_hostio_fstat (struct target_ops
*self
,
11724 int fd
, struct stat
*st
,
11727 struct remote_state
*rs
= get_remote_state ();
11729 int left
= get_remote_packet_size ();
11730 int attachment_len
, ret
;
11732 struct fio_stat fst
;
11735 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
11737 remote_buffer_add_int (&p
, &left
, fd
);
11739 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
11740 remote_errno
, &attachment
,
11744 if (*remote_errno
!= FILEIO_ENOSYS
)
11747 /* Strictly we should return -1, ENOSYS here, but when
11748 "set sysroot remote:" was implemented in August 2008
11749 BFD's need for a stat function was sidestepped with
11750 this hack. This was not remedied until March 2015
11751 so we retain the previous behavior to avoid breaking
11754 Note that the memset is a March 2015 addition; older
11755 GDBs set st_size *and nothing else* so the structure
11756 would have garbage in all other fields. This might
11757 break something but retaining the previous behavior
11758 here would be just too wrong. */
11760 memset (st
, 0, sizeof (struct stat
));
11761 st
->st_size
= INT_MAX
;
11765 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11766 (gdb_byte
*) &fst
, sizeof (fst
));
11768 if (read_len
!= ret
)
11769 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
11771 if (read_len
!= sizeof (fst
))
11772 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11773 read_len
, (int) sizeof (fst
));
11775 remote_fileio_to_host_stat (&fst
, st
);
11780 /* Implementation of to_filesystem_is_local. */
11783 remote_filesystem_is_local (struct target_ops
*self
)
11785 /* Valgrind GDB presents itself as a remote target but works
11786 on the local filesystem: it does not implement remote get
11787 and users are not expected to set a sysroot. To handle
11788 this case we treat the remote filesystem as local if the
11789 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11790 does not support vFile:open. */
11791 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
11793 enum packet_support ps
= packet_support (PACKET_vFile_open
);
11795 if (ps
== PACKET_SUPPORT_UNKNOWN
)
11797 int fd
, remote_errno
;
11799 /* Try opening a file to probe support. The supplied
11800 filename is irrelevant, we only care about whether
11801 the stub recognizes the packet or not. */
11802 fd
= remote_hostio_open (self
, NULL
, "just probing",
11803 FILEIO_O_RDONLY
, 0700, 0,
11807 remote_hostio_close (self
, fd
, &remote_errno
);
11809 ps
= packet_support (PACKET_vFile_open
);
11812 if (ps
== PACKET_DISABLE
)
11814 static int warning_issued
= 0;
11816 if (!warning_issued
)
11818 warning (_("remote target does not support file"
11819 " transfer, attempting to access files"
11820 " from local filesystem."));
11821 warning_issued
= 1;
11832 remote_fileio_errno_to_host (int errnum
)
11838 case FILEIO_ENOENT
:
11846 case FILEIO_EACCES
:
11848 case FILEIO_EFAULT
:
11852 case FILEIO_EEXIST
:
11854 case FILEIO_ENODEV
:
11856 case FILEIO_ENOTDIR
:
11858 case FILEIO_EISDIR
:
11860 case FILEIO_EINVAL
:
11862 case FILEIO_ENFILE
:
11864 case FILEIO_EMFILE
:
11868 case FILEIO_ENOSPC
:
11870 case FILEIO_ESPIPE
:
11874 case FILEIO_ENOSYS
:
11876 case FILEIO_ENAMETOOLONG
:
11877 return ENAMETOOLONG
;
11883 remote_hostio_error (int errnum
)
11885 int host_error
= remote_fileio_errno_to_host (errnum
);
11887 if (host_error
== -1)
11888 error (_("Unknown remote I/O error %d"), errnum
);
11890 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
11894 remote_hostio_close_cleanup (void *opaque
)
11896 int fd
= *(int *) opaque
;
11899 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
11903 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
11905 struct cleanup
*back_to
, *close_cleanup
;
11906 int retcode
, fd
, remote_errno
, bytes
, io_size
;
11909 int bytes_in_buffer
;
11912 struct remote_state
*rs
= get_remote_state ();
11914 if (!rs
->remote_desc
)
11915 error (_("command can only be used with remote target"));
11917 file
= gdb_fopen_cloexec (local_file
, "rb");
11919 perror_with_name (local_file
);
11920 back_to
= make_cleanup_fclose (file
);
11922 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11923 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
11925 0700, 0, &remote_errno
);
11927 remote_hostio_error (remote_errno
);
11929 /* Send up to this many bytes at once. They won't all fit in the
11930 remote packet limit, so we'll transfer slightly fewer. */
11931 io_size
= get_remote_packet_size ();
11932 buffer
= (gdb_byte
*) xmalloc (io_size
);
11933 make_cleanup (xfree
, buffer
);
11935 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11937 bytes_in_buffer
= 0;
11940 while (bytes_in_buffer
|| !saw_eof
)
11944 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
11945 io_size
- bytes_in_buffer
,
11950 error (_("Error reading %s."), local_file
);
11953 /* EOF. Unless there is something still in the
11954 buffer from the last iteration, we are done. */
11956 if (bytes_in_buffer
== 0)
11964 bytes
+= bytes_in_buffer
;
11965 bytes_in_buffer
= 0;
11967 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
11969 offset
, &remote_errno
);
11972 remote_hostio_error (remote_errno
);
11973 else if (retcode
== 0)
11974 error (_("Remote write of %d bytes returned 0!"), bytes
);
11975 else if (retcode
< bytes
)
11977 /* Short write. Save the rest of the read data for the next
11979 bytes_in_buffer
= bytes
- retcode
;
11980 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
11986 discard_cleanups (close_cleanup
);
11987 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
11988 remote_hostio_error (remote_errno
);
11991 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
11992 do_cleanups (back_to
);
11996 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
11998 struct cleanup
*back_to
, *close_cleanup
;
11999 int fd
, remote_errno
, bytes
, io_size
;
12003 struct remote_state
*rs
= get_remote_state ();
12005 if (!rs
->remote_desc
)
12006 error (_("command can only be used with remote target"));
12008 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
12009 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12012 remote_hostio_error (remote_errno
);
12014 file
= gdb_fopen_cloexec (local_file
, "wb");
12016 perror_with_name (local_file
);
12017 back_to
= make_cleanup_fclose (file
);
12019 /* Send up to this many bytes at once. They won't all fit in the
12020 remote packet limit, so we'll transfer slightly fewer. */
12021 io_size
= get_remote_packet_size ();
12022 buffer
= (gdb_byte
*) xmalloc (io_size
);
12023 make_cleanup (xfree
, buffer
);
12025 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
12030 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
12031 fd
, buffer
, io_size
, offset
, &remote_errno
);
12033 /* Success, but no bytes, means end-of-file. */
12036 remote_hostio_error (remote_errno
);
12040 bytes
= fwrite (buffer
, 1, bytes
, file
);
12042 perror_with_name (local_file
);
12045 discard_cleanups (close_cleanup
);
12046 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12047 remote_hostio_error (remote_errno
);
12050 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12051 do_cleanups (back_to
);
12055 remote_file_delete (const char *remote_file
, int from_tty
)
12057 int retcode
, remote_errno
;
12058 struct remote_state
*rs
= get_remote_state ();
12060 if (!rs
->remote_desc
)
12061 error (_("command can only be used with remote target"));
12063 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
12064 NULL
, remote_file
, &remote_errno
);
12066 remote_hostio_error (remote_errno
);
12069 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12073 remote_put_command (char *args
, int from_tty
)
12075 struct cleanup
*back_to
;
12079 error_no_arg (_("file to put"));
12081 argv
= gdb_buildargv (args
);
12082 back_to
= make_cleanup_freeargv (argv
);
12083 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12084 error (_("Invalid parameters to remote put"));
12086 remote_file_put (argv
[0], argv
[1], from_tty
);
12088 do_cleanups (back_to
);
12092 remote_get_command (char *args
, int from_tty
)
12094 struct cleanup
*back_to
;
12098 error_no_arg (_("file to get"));
12100 argv
= gdb_buildargv (args
);
12101 back_to
= make_cleanup_freeargv (argv
);
12102 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12103 error (_("Invalid parameters to remote get"));
12105 remote_file_get (argv
[0], argv
[1], from_tty
);
12107 do_cleanups (back_to
);
12111 remote_delete_command (char *args
, int from_tty
)
12113 struct cleanup
*back_to
;
12117 error_no_arg (_("file to delete"));
12119 argv
= gdb_buildargv (args
);
12120 back_to
= make_cleanup_freeargv (argv
);
12121 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12122 error (_("Invalid parameters to remote delete"));
12124 remote_file_delete (argv
[0], from_tty
);
12126 do_cleanups (back_to
);
12130 remote_command (char *args
, int from_tty
)
12132 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12136 remote_can_execute_reverse (struct target_ops
*self
)
12138 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12139 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12146 remote_supports_non_stop (struct target_ops
*self
)
12152 remote_supports_disable_randomization (struct target_ops
*self
)
12154 /* Only supported in extended mode. */
12159 remote_supports_multi_process (struct target_ops
*self
)
12161 struct remote_state
*rs
= get_remote_state ();
12163 return remote_multi_process_p (rs
);
12167 remote_supports_cond_tracepoints (void)
12169 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12173 remote_supports_cond_breakpoints (struct target_ops
*self
)
12175 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12179 remote_supports_fast_tracepoints (void)
12181 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12185 remote_supports_static_tracepoints (void)
12187 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12191 remote_supports_install_in_trace (void)
12193 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12197 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
12199 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12204 remote_supports_string_tracing (struct target_ops
*self
)
12206 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12210 remote_can_run_breakpoint_commands (struct target_ops
*self
)
12212 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12216 remote_trace_init (struct target_ops
*self
)
12219 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12220 if (strcmp (target_buf
, "OK") != 0)
12221 error (_("Target does not support this command."));
12224 static void free_actions_list (char **actions_list
);
12225 static void free_actions_list_cleanup_wrapper (void *);
12227 free_actions_list_cleanup_wrapper (void *al
)
12229 free_actions_list ((char **) al
);
12233 free_actions_list (char **actions_list
)
12237 if (actions_list
== 0)
12240 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
12241 xfree (actions_list
[ndx
]);
12243 xfree (actions_list
);
12246 /* Recursive routine to walk through command list including loops, and
12247 download packets for each command. */
12250 remote_download_command_source (int num
, ULONGEST addr
,
12251 struct command_line
*cmds
)
12253 struct remote_state
*rs
= get_remote_state ();
12254 struct command_line
*cmd
;
12256 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12258 QUIT
; /* Allow user to bail out with ^C. */
12259 strcpy (rs
->buf
, "QTDPsrc:");
12260 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12261 rs
->buf
+ strlen (rs
->buf
),
12262 rs
->buf_size
- strlen (rs
->buf
));
12264 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12265 if (strcmp (target_buf
, "OK"))
12266 warning (_("Target does not support source download."));
12268 if (cmd
->control_type
== while_control
12269 || cmd
->control_type
== while_stepping_control
)
12271 remote_download_command_source (num
, addr
, *cmd
->body_list
);
12273 QUIT
; /* Allow user to bail out with ^C. */
12274 strcpy (rs
->buf
, "QTDPsrc:");
12275 encode_source_string (num
, addr
, "cmd", "end",
12276 rs
->buf
+ strlen (rs
->buf
),
12277 rs
->buf_size
- strlen (rs
->buf
));
12279 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12280 if (strcmp (target_buf
, "OK"))
12281 warning (_("Target does not support source download."));
12287 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
12289 #define BUF_SIZE 2048
12293 char buf
[BUF_SIZE
];
12294 char **tdp_actions
;
12295 char **stepping_actions
;
12297 struct cleanup
*old_chain
= NULL
;
12299 struct breakpoint
*b
= loc
->owner
;
12300 struct tracepoint
*t
= (struct tracepoint
*) b
;
12302 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12303 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
12305 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
12308 tpaddr
= loc
->address
;
12309 sprintf_vma (addrbuf
, tpaddr
);
12310 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
12311 addrbuf
, /* address */
12312 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12313 t
->step_count
, t
->pass_count
);
12314 /* Fast tracepoints are mostly handled by the target, but we can
12315 tell the target how big of an instruction block should be moved
12317 if (b
->type
== bp_fast_tracepoint
)
12319 /* Only test for support at download time; we may not know
12320 target capabilities at definition time. */
12321 if (remote_supports_fast_tracepoints ())
12323 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12325 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
12326 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12328 /* If it passed validation at definition but fails now,
12329 something is very wrong. */
12330 internal_error (__FILE__
, __LINE__
,
12331 _("Fast tracepoint not "
12332 "valid during download"));
12335 /* Fast tracepoints are functionally identical to regular
12336 tracepoints, so don't take lack of support as a reason to
12337 give up on the trace run. */
12338 warning (_("Target does not support fast tracepoints, "
12339 "downloading %d as regular tracepoint"), b
->number
);
12341 else if (b
->type
== bp_static_tracepoint
)
12343 /* Only test for support at download time; we may not know
12344 target capabilities at definition time. */
12345 if (remote_supports_static_tracepoints ())
12347 struct static_tracepoint_marker marker
;
12349 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12350 strcat (buf
, ":S");
12352 error (_("Static tracepoint not valid during download"));
12355 /* Fast tracepoints are functionally identical to regular
12356 tracepoints, so don't take lack of support as a reason
12357 to give up on the trace run. */
12358 error (_("Target does not support static tracepoints"));
12360 /* If the tracepoint has a conditional, make it into an agent
12361 expression and append to the definition. */
12364 /* Only test support at download time, we may not know target
12365 capabilities at definition time. */
12366 if (remote_supports_cond_tracepoints ())
12368 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
.get ());
12369 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
12371 pkt
= buf
+ strlen (buf
);
12372 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12373 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12377 warning (_("Target does not support conditional tracepoints, "
12378 "ignoring tp %d cond"), b
->number
);
12381 if (b
->commands
|| *default_collect
)
12384 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12385 if (strcmp (target_buf
, "OK"))
12386 error (_("Target does not support tracepoints."));
12388 /* do_single_steps (t); */
12391 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
12393 QUIT
; /* Allow user to bail out with ^C. */
12394 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
12395 b
->number
, addrbuf
, /* address */
12397 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
12400 remote_get_noisy_reply (&target_buf
,
12402 if (strcmp (target_buf
, "OK"))
12403 error (_("Error on target while setting tracepoints."));
12406 if (stepping_actions
)
12408 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
12410 QUIT
; /* Allow user to bail out with ^C. */
12411 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
12412 b
->number
, addrbuf
, /* address */
12413 ((ndx
== 0) ? "S" : ""),
12414 stepping_actions
[ndx
],
12415 (stepping_actions
[ndx
+ 1] ? "-" : ""));
12417 remote_get_noisy_reply (&target_buf
,
12419 if (strcmp (target_buf
, "OK"))
12420 error (_("Error on target while setting tracepoints."));
12424 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12426 if (b
->location
!= NULL
)
12428 strcpy (buf
, "QTDPsrc:");
12429 encode_source_string (b
->number
, loc
->address
, "at",
12430 event_location_to_string (b
->location
.get ()),
12431 buf
+ strlen (buf
), 2048 - strlen (buf
));
12433 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12434 if (strcmp (target_buf
, "OK"))
12435 warning (_("Target does not support source download."));
12437 if (b
->cond_string
)
12439 strcpy (buf
, "QTDPsrc:");
12440 encode_source_string (b
->number
, loc
->address
,
12441 "cond", b
->cond_string
, buf
+ strlen (buf
),
12442 2048 - strlen (buf
));
12444 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12445 if (strcmp (target_buf
, "OK"))
12446 warning (_("Target does not support source download."));
12448 remote_download_command_source (b
->number
, loc
->address
,
12449 breakpoint_commands (b
));
12452 do_cleanups (old_chain
);
12456 remote_can_download_tracepoint (struct target_ops
*self
)
12458 struct remote_state
*rs
= get_remote_state ();
12459 struct trace_status
*ts
;
12462 /* Don't try to install tracepoints until we've relocated our
12463 symbols, and fetched and merged the target's tracepoint list with
12465 if (rs
->starting_up
)
12468 ts
= current_trace_status ();
12469 status
= remote_get_trace_status (self
, ts
);
12471 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12474 /* If we are in a tracing experiment, but remote stub doesn't support
12475 installing tracepoint in trace, we have to return. */
12476 if (!remote_supports_install_in_trace ())
12484 remote_download_trace_state_variable (struct target_ops
*self
,
12485 struct trace_state_variable
*tsv
)
12487 struct remote_state
*rs
= get_remote_state ();
12490 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12491 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
12493 p
= rs
->buf
+ strlen (rs
->buf
);
12494 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
12495 error (_("Trace state variable name too long for tsv definition packet"));
12496 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
12499 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12500 if (*target_buf
== '\0')
12501 error (_("Target does not support this command."));
12502 if (strcmp (target_buf
, "OK") != 0)
12503 error (_("Error on target while downloading trace state variable."));
12507 remote_enable_tracepoint (struct target_ops
*self
,
12508 struct bp_location
*location
)
12510 struct remote_state
*rs
= get_remote_state ();
12513 sprintf_vma (addr_buf
, location
->address
);
12514 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
12515 location
->owner
->number
, addr_buf
);
12517 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12518 if (*rs
->buf
== '\0')
12519 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12520 if (strcmp (rs
->buf
, "OK") != 0)
12521 error (_("Error on target while enabling tracepoint."));
12525 remote_disable_tracepoint (struct target_ops
*self
,
12526 struct bp_location
*location
)
12528 struct remote_state
*rs
= get_remote_state ();
12531 sprintf_vma (addr_buf
, location
->address
);
12532 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
12533 location
->owner
->number
, addr_buf
);
12535 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12536 if (*rs
->buf
== '\0')
12537 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12538 if (strcmp (rs
->buf
, "OK") != 0)
12539 error (_("Error on target while disabling tracepoint."));
12543 remote_trace_set_readonly_regions (struct target_ops
*self
)
12547 bfd_size_type size
;
12553 return; /* No information to give. */
12555 strcpy (target_buf
, "QTro");
12556 offset
= strlen (target_buf
);
12557 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
12559 char tmp1
[40], tmp2
[40];
12562 if ((s
->flags
& SEC_LOAD
) == 0 ||
12563 /* (s->flags & SEC_CODE) == 0 || */
12564 (s
->flags
& SEC_READONLY
) == 0)
12568 vma
= bfd_get_section_vma (abfd
, s
);
12569 size
= bfd_get_section_size (s
);
12570 sprintf_vma (tmp1
, vma
);
12571 sprintf_vma (tmp2
, vma
+ size
);
12572 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
12573 if (offset
+ sec_length
+ 1 > target_buf_size
)
12575 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
12577 Too many sections for read-only sections definition packet."));
12580 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
12582 offset
+= sec_length
;
12586 putpkt (target_buf
);
12587 getpkt (&target_buf
, &target_buf_size
, 0);
12592 remote_trace_start (struct target_ops
*self
)
12594 putpkt ("QTStart");
12595 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12596 if (*target_buf
== '\0')
12597 error (_("Target does not support this command."));
12598 if (strcmp (target_buf
, "OK") != 0)
12599 error (_("Bogus reply from target: %s"), target_buf
);
12603 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
12605 /* Initialize it just to avoid a GCC false warning. */
12607 /* FIXME we need to get register block size some other way. */
12608 extern int trace_regblock_size
;
12609 enum packet_result result
;
12611 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
12614 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
12616 putpkt ("qTStatus");
12620 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12622 CATCH (ex
, RETURN_MASK_ERROR
)
12624 if (ex
.error
!= TARGET_CLOSE_ERROR
)
12626 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
12629 throw_exception (ex
);
12633 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
12635 /* If the remote target doesn't do tracing, flag it. */
12636 if (result
== PACKET_UNKNOWN
)
12639 /* We're working with a live target. */
12640 ts
->filename
= NULL
;
12643 error (_("Bogus trace status reply from target: %s"), target_buf
);
12645 /* Function 'parse_trace_status' sets default value of each field of
12646 'ts' at first, so we don't have to do it here. */
12647 parse_trace_status (p
, ts
);
12649 return ts
->running
;
12653 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
12654 struct uploaded_tp
*utp
)
12656 struct remote_state
*rs
= get_remote_state ();
12658 struct bp_location
*loc
;
12659 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
12660 size_t size
= get_remote_packet_size ();
12665 tp
->traceframe_usage
= 0;
12666 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
12668 /* If the tracepoint was never downloaded, don't go asking for
12670 if (tp
->number_on_target
== 0)
12672 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
12673 phex_nz (loc
->address
, 0));
12675 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12676 if (reply
&& *reply
)
12679 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12685 utp
->hit_count
= 0;
12686 utp
->traceframe_usage
= 0;
12687 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
12688 phex_nz (utp
->addr
, 0));
12690 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12691 if (reply
&& *reply
)
12694 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12700 remote_trace_stop (struct target_ops
*self
)
12703 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12704 if (*target_buf
== '\0')
12705 error (_("Target does not support this command."));
12706 if (strcmp (target_buf
, "OK") != 0)
12707 error (_("Bogus reply from target: %s"), target_buf
);
12711 remote_trace_find (struct target_ops
*self
,
12712 enum trace_find_type type
, int num
,
12713 CORE_ADDR addr1
, CORE_ADDR addr2
,
12716 struct remote_state
*rs
= get_remote_state ();
12717 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12719 int target_frameno
= -1, target_tracept
= -1;
12721 /* Lookups other than by absolute frame number depend on the current
12722 trace selected, so make sure it is correct on the remote end
12724 if (type
!= tfind_number
)
12725 set_remote_traceframe ();
12728 strcpy (p
, "QTFrame:");
12729 p
= strchr (p
, '\0');
12733 xsnprintf (p
, endbuf
- p
, "%x", num
);
12736 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
12739 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
12742 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
12743 phex_nz (addr2
, 0));
12745 case tfind_outside
:
12746 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
12747 phex_nz (addr2
, 0));
12750 error (_("Unknown trace find type %d"), type
);
12754 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
12755 if (*reply
== '\0')
12756 error (_("Target does not support this command."));
12758 while (reply
&& *reply
)
12763 target_frameno
= (int) strtol (p
, &reply
, 16);
12765 error (_("Unable to parse trace frame number"));
12766 /* Don't update our remote traceframe number cache on failure
12767 to select a remote traceframe. */
12768 if (target_frameno
== -1)
12773 target_tracept
= (int) strtol (p
, &reply
, 16);
12775 error (_("Unable to parse tracepoint number"));
12777 case 'O': /* "OK"? */
12778 if (reply
[1] == 'K' && reply
[2] == '\0')
12781 error (_("Bogus reply from target: %s"), reply
);
12784 error (_("Bogus reply from target: %s"), reply
);
12787 *tpp
= target_tracept
;
12789 rs
->remote_traceframe_number
= target_frameno
;
12790 return target_frameno
;
12794 remote_get_trace_state_variable_value (struct target_ops
*self
,
12795 int tsvnum
, LONGEST
*val
)
12797 struct remote_state
*rs
= get_remote_state ();
12801 set_remote_traceframe ();
12803 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
12805 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12806 if (reply
&& *reply
)
12810 unpack_varlen_hex (reply
+ 1, &uval
);
12811 *val
= (LONGEST
) uval
;
12819 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
12821 struct remote_state
*rs
= get_remote_state ();
12825 strcpy (p
, "QTSave:");
12827 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
12828 error (_("Remote file name too long for trace save packet"));
12829 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
12832 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12833 if (*reply
== '\0')
12834 error (_("Target does not support this command."));
12835 if (strcmp (reply
, "OK") != 0)
12836 error (_("Bogus reply from target: %s"), reply
);
12840 /* This is basically a memory transfer, but needs to be its own packet
12841 because we don't know how the target actually organizes its trace
12842 memory, plus we want to be able to ask for as much as possible, but
12843 not be unhappy if we don't get as much as we ask for. */
12846 remote_get_raw_trace_data (struct target_ops
*self
,
12847 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
12849 struct remote_state
*rs
= get_remote_state ();
12855 strcpy (p
, "qTBuffer:");
12857 p
+= hexnumstr (p
, offset
);
12859 p
+= hexnumstr (p
, len
);
12863 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12864 if (reply
&& *reply
)
12866 /* 'l' by itself means we're at the end of the buffer and
12867 there is nothing more to get. */
12871 /* Convert the reply into binary. Limit the number of bytes to
12872 convert according to our passed-in buffer size, rather than
12873 what was returned in the packet; if the target is
12874 unexpectedly generous and gives us a bigger reply than we
12875 asked for, we don't want to crash. */
12876 rslt
= hex2bin (target_buf
, buf
, len
);
12880 /* Something went wrong, flag as an error. */
12885 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
12887 struct remote_state
*rs
= get_remote_state ();
12889 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
12893 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
12895 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12896 if (*reply
== '\0')
12897 error (_("Target does not support this command."));
12898 if (strcmp (reply
, "OK") != 0)
12899 error (_("Bogus reply from target: %s"), reply
);
12902 warning (_("Target does not support disconnected tracing."));
12906 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
12908 struct thread_info
*info
= find_thread_ptid (ptid
);
12910 if (info
&& info
->priv
)
12911 return info
->priv
->core
;
12916 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
12918 struct remote_state
*rs
= get_remote_state ();
12921 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
12923 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12924 if (*reply
== '\0')
12925 error (_("Target does not support this command."));
12926 if (strcmp (reply
, "OK") != 0)
12927 error (_("Bogus reply from target: %s"), reply
);
12930 static struct traceframe_info
*
12931 remote_traceframe_info (struct target_ops
*self
)
12935 text
= target_read_stralloc (¤t_target
,
12936 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
12939 struct traceframe_info
*info
;
12940 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
12942 info
= parse_traceframe_info (text
);
12943 do_cleanups (back_to
);
12950 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12951 instruction on which a fast tracepoint may be placed. Returns -1
12952 if the packet is not supported, and 0 if the minimum instruction
12953 length is unknown. */
12956 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
12958 struct remote_state
*rs
= get_remote_state ();
12961 /* If we're not debugging a process yet, the IPA can't be
12963 if (!target_has_execution
)
12966 /* Make sure the remote is pointing at the right process. */
12967 set_general_process ();
12969 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
12971 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12972 if (*reply
== '\0')
12976 ULONGEST min_insn_len
;
12978 unpack_varlen_hex (reply
, &min_insn_len
);
12980 return (int) min_insn_len
;
12985 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
12987 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
12989 struct remote_state
*rs
= get_remote_state ();
12990 char *buf
= rs
->buf
;
12991 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12992 enum packet_result result
;
12994 gdb_assert (val
>= 0 || val
== -1);
12995 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
12996 /* Send -1 as literal "-1" to avoid host size dependency. */
13000 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13003 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13006 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
13007 result
= packet_ok (rs
->buf
,
13008 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13010 if (result
!= PACKET_OK
)
13011 warning (_("Bogus reply from target: %s"), rs
->buf
);
13016 remote_set_trace_notes (struct target_ops
*self
,
13017 const char *user
, const char *notes
,
13018 const char *stop_notes
)
13020 struct remote_state
*rs
= get_remote_state ();
13022 char *buf
= rs
->buf
;
13023 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13026 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13029 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13030 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13036 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13037 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13043 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13044 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13048 /* Ensure the buffer is terminated. */
13052 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
13053 if (*reply
== '\0')
13056 if (strcmp (reply
, "OK") != 0)
13057 error (_("Bogus reply from target: %s"), reply
);
13063 remote_use_agent (struct target_ops
*self
, int use
)
13065 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13067 struct remote_state
*rs
= get_remote_state ();
13069 /* If the stub supports QAgent. */
13070 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
13072 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13074 if (strcmp (rs
->buf
, "OK") == 0)
13085 remote_can_use_agent (struct target_ops
*self
)
13087 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13090 struct btrace_target_info
13092 /* The ptid of the traced thread. */
13095 /* The obtained branch trace configuration. */
13096 struct btrace_config conf
;
13099 /* Reset our idea of our target's btrace configuration. */
13102 remote_btrace_reset (void)
13104 struct remote_state
*rs
= get_remote_state ();
13106 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13109 /* Check whether the target supports branch tracing. */
13112 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
13114 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
13116 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
13121 case BTRACE_FORMAT_NONE
:
13124 case BTRACE_FORMAT_BTS
:
13125 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
13127 case BTRACE_FORMAT_PT
:
13128 /* The trace is decoded on the host. Even if our target supports it,
13129 we still need to have libipt to decode the trace. */
13130 #if defined (HAVE_LIBIPT)
13131 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
13132 #else /* !defined (HAVE_LIBIPT) */
13134 #endif /* !defined (HAVE_LIBIPT) */
13137 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
13140 /* Synchronize the configuration with the target. */
13143 btrace_sync_conf (const struct btrace_config
*conf
)
13145 struct packet_config
*packet
;
13146 struct remote_state
*rs
;
13147 char *buf
, *pos
, *endbuf
;
13149 rs
= get_remote_state ();
13151 endbuf
= buf
+ get_remote_packet_size ();
13153 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13154 if (packet_config_support (packet
) == PACKET_ENABLE
13155 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13158 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13162 getpkt (&buf
, &rs
->buf_size
, 0);
13164 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13166 if (buf
[0] == 'E' && buf
[1] == '.')
13167 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13169 error (_("Failed to configure the BTS buffer size."));
13172 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13175 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13176 if (packet_config_support (packet
) == PACKET_ENABLE
13177 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13180 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13184 getpkt (&buf
, &rs
->buf_size
, 0);
13186 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13188 if (buf
[0] == 'E' && buf
[1] == '.')
13189 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13191 error (_("Failed to configure the trace buffer size."));
13194 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13198 /* Read the current thread's btrace configuration from the target and
13199 store it into CONF. */
13202 btrace_read_config (struct btrace_config
*conf
)
13206 xml
= target_read_stralloc (¤t_target
,
13207 TARGET_OBJECT_BTRACE_CONF
, "");
13210 struct cleanup
*cleanup
;
13212 cleanup
= make_cleanup (xfree
, xml
);
13213 parse_xml_btrace_conf (conf
, xml
);
13214 do_cleanups (cleanup
);
13218 /* Maybe reopen target btrace. */
13221 remote_btrace_maybe_reopen (void)
13223 struct remote_state
*rs
= get_remote_state ();
13224 struct thread_info
*tp
;
13225 int btrace_target_pushed
= 0;
13228 scoped_restore_current_thread restore_thread
;
13230 ALL_NON_EXITED_THREADS (tp
)
13232 set_general_thread (tp
->ptid
);
13234 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13235 btrace_read_config (&rs
->btrace_config
);
13237 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13240 #if !defined (HAVE_LIBIPT)
13241 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13246 warning (_("GDB does not support Intel Processor Trace. "
13247 "\"record\" will not work in this session."));
13252 #endif /* !defined (HAVE_LIBIPT) */
13254 /* Push target, once, but before anything else happens. This way our
13255 changes to the threads will be cleaned up by unpushing the target
13256 in case btrace_read_config () throws. */
13257 if (!btrace_target_pushed
)
13259 btrace_target_pushed
= 1;
13260 record_btrace_push_target ();
13261 printf_filtered (_("Target is recording using %s.\n"),
13262 btrace_format_string (rs
->btrace_config
.format
));
13265 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13266 tp
->btrace
.target
->ptid
= tp
->ptid
;
13267 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13271 /* Enable branch tracing. */
13273 static struct btrace_target_info
*
13274 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
13275 const struct btrace_config
*conf
)
13277 struct btrace_target_info
*tinfo
= NULL
;
13278 struct packet_config
*packet
= NULL
;
13279 struct remote_state
*rs
= get_remote_state ();
13280 char *buf
= rs
->buf
;
13281 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13283 switch (conf
->format
)
13285 case BTRACE_FORMAT_BTS
:
13286 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13289 case BTRACE_FORMAT_PT
:
13290 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13294 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13295 error (_("Target does not support branch tracing."));
13297 btrace_sync_conf (conf
);
13299 set_general_thread (ptid
);
13301 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13303 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13305 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13307 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13308 error (_("Could not enable branch tracing for %s: %s"),
13309 target_pid_to_str (ptid
), rs
->buf
+ 2);
13311 error (_("Could not enable branch tracing for %s."),
13312 target_pid_to_str (ptid
));
13315 tinfo
= XCNEW (struct btrace_target_info
);
13316 tinfo
->ptid
= ptid
;
13318 /* If we fail to read the configuration, we lose some information, but the
13319 tracing itself is not impacted. */
13322 btrace_read_config (&tinfo
->conf
);
13324 CATCH (err
, RETURN_MASK_ERROR
)
13326 if (err
.message
!= NULL
)
13327 warning ("%s", err
.message
);
13334 /* Disable branch tracing. */
13337 remote_disable_btrace (struct target_ops
*self
,
13338 struct btrace_target_info
*tinfo
)
13340 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13341 struct remote_state
*rs
= get_remote_state ();
13342 char *buf
= rs
->buf
;
13343 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13345 if (packet_config_support (packet
) != PACKET_ENABLE
)
13346 error (_("Target does not support branch tracing."));
13348 set_general_thread (tinfo
->ptid
);
13350 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13352 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13354 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13356 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13357 error (_("Could not disable branch tracing for %s: %s"),
13358 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
13360 error (_("Could not disable branch tracing for %s."),
13361 target_pid_to_str (tinfo
->ptid
));
13367 /* Teardown branch tracing. */
13370 remote_teardown_btrace (struct target_ops
*self
,
13371 struct btrace_target_info
*tinfo
)
13373 /* We must not talk to the target during teardown. */
13377 /* Read the branch trace. */
13379 static enum btrace_error
13380 remote_read_btrace (struct target_ops
*self
,
13381 struct btrace_data
*btrace
,
13382 struct btrace_target_info
*tinfo
,
13383 enum btrace_read_type type
)
13385 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13386 struct cleanup
*cleanup
;
13390 if (packet_config_support (packet
) != PACKET_ENABLE
)
13391 error (_("Target does not support branch tracing."));
13393 #if !defined(HAVE_LIBEXPAT)
13394 error (_("Cannot process branch tracing result. XML parsing not supported."));
13399 case BTRACE_READ_ALL
:
13402 case BTRACE_READ_NEW
:
13405 case BTRACE_READ_DELTA
:
13409 internal_error (__FILE__
, __LINE__
,
13410 _("Bad branch tracing read type: %u."),
13411 (unsigned int) type
);
13414 xml
= target_read_stralloc (¤t_target
,
13415 TARGET_OBJECT_BTRACE
, annex
);
13417 return BTRACE_ERR_UNKNOWN
;
13419 cleanup
= make_cleanup (xfree
, xml
);
13420 parse_xml_btrace (btrace
, xml
);
13421 do_cleanups (cleanup
);
13423 return BTRACE_ERR_NONE
;
13426 static const struct btrace_config
*
13427 remote_btrace_conf (struct target_ops
*self
,
13428 const struct btrace_target_info
*tinfo
)
13430 return &tinfo
->conf
;
13434 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
13436 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13440 /* Implementation of to_load. */
13443 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
13445 generic_load (name
, from_tty
);
13448 /* Accepts an integer PID; returns a string representing a file that
13449 can be opened on the remote side to get the symbols for the child
13450 process. Returns NULL if the operation is not supported. */
13453 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
13455 static char *filename
= NULL
;
13456 struct inferior
*inf
;
13457 char *annex
= NULL
;
13459 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13462 if (filename
!= NULL
)
13465 inf
= find_inferior_pid (pid
);
13467 internal_error (__FILE__
, __LINE__
,
13468 _("not currently attached to process %d"), pid
);
13470 if (!inf
->fake_pid_p
)
13472 const int annex_size
= 9;
13474 annex
= (char *) alloca (annex_size
);
13475 xsnprintf (annex
, annex_size
, "%x", pid
);
13478 filename
= target_read_stralloc (¤t_target
,
13479 TARGET_OBJECT_EXEC_FILE
, annex
);
13484 /* Implement the to_can_do_single_step target_ops method. */
13487 remote_can_do_single_step (struct target_ops
*ops
)
13489 /* We can only tell whether target supports single step or not by
13490 supported s and S vCont actions if the stub supports vContSupported
13491 feature. If the stub doesn't support vContSupported feature,
13492 we have conservatively to think target doesn't supports single
13494 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13496 struct remote_state
*rs
= get_remote_state ();
13498 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13499 remote_vcont_probe (rs
);
13501 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13507 /* Implementation of the to_execution_direction method for the remote
13510 static enum exec_direction_kind
13511 remote_execution_direction (struct target_ops
*self
)
13513 struct remote_state
*rs
= get_remote_state ();
13515 return rs
->last_resume_exec_dir
;
13519 init_remote_ops (void)
13521 remote_ops
.to_shortname
= "remote";
13522 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
13523 remote_ops
.to_doc
=
13524 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13525 Specify the serial device it is connected to\n\
13526 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13527 remote_ops
.to_open
= remote_open
;
13528 remote_ops
.to_close
= remote_close
;
13529 remote_ops
.to_detach
= remote_detach
;
13530 remote_ops
.to_disconnect
= remote_disconnect
;
13531 remote_ops
.to_resume
= remote_resume
;
13532 remote_ops
.to_commit_resume
= remote_commit_resume
;
13533 remote_ops
.to_wait
= remote_wait
;
13534 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
13535 remote_ops
.to_store_registers
= remote_store_registers
;
13536 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
13537 remote_ops
.to_files_info
= remote_files_info
;
13538 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
13539 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
13540 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
13541 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
13542 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
13543 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
13544 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
13545 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
13546 remote_ops
.to_watchpoint_addr_within_range
=
13547 remote_watchpoint_addr_within_range
;
13548 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
13549 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
13550 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
13551 remote_ops
.to_region_ok_for_hw_watchpoint
13552 = remote_region_ok_for_hw_watchpoint
;
13553 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
13554 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
13555 remote_ops
.to_kill
= remote_kill
;
13556 remote_ops
.to_load
= remote_load
;
13557 remote_ops
.to_mourn_inferior
= remote_mourn
;
13558 remote_ops
.to_pass_signals
= remote_pass_signals
;
13559 remote_ops
.to_set_syscall_catchpoint
= remote_set_syscall_catchpoint
;
13560 remote_ops
.to_program_signals
= remote_program_signals
;
13561 remote_ops
.to_thread_alive
= remote_thread_alive
;
13562 remote_ops
.to_thread_name
= remote_thread_name
;
13563 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
13564 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
13565 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
13566 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
13567 remote_ops
.to_stop
= remote_stop
;
13568 remote_ops
.to_interrupt
= remote_interrupt
;
13569 remote_ops
.to_pass_ctrlc
= remote_pass_ctrlc
;
13570 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
13571 remote_ops
.to_get_memory_xfer_limit
= remote_get_memory_xfer_limit
;
13572 remote_ops
.to_rcmd
= remote_rcmd
;
13573 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
13574 remote_ops
.to_log_command
= serial_log_command
;
13575 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
13576 remote_ops
.to_stratum
= process_stratum
;
13577 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
13578 remote_ops
.to_has_memory
= default_child_has_memory
;
13579 remote_ops
.to_has_stack
= default_child_has_stack
;
13580 remote_ops
.to_has_registers
= default_child_has_registers
;
13581 remote_ops
.to_has_execution
= default_child_has_execution
;
13582 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
13583 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
13584 remote_ops
.to_magic
= OPS_MAGIC
;
13585 remote_ops
.to_memory_map
= remote_memory_map
;
13586 remote_ops
.to_flash_erase
= remote_flash_erase
;
13587 remote_ops
.to_flash_done
= remote_flash_done
;
13588 remote_ops
.to_read_description
= remote_read_description
;
13589 remote_ops
.to_search_memory
= remote_search_memory
;
13590 remote_ops
.to_can_async_p
= remote_can_async_p
;
13591 remote_ops
.to_is_async_p
= remote_is_async_p
;
13592 remote_ops
.to_async
= remote_async
;
13593 remote_ops
.to_thread_events
= remote_thread_events
;
13594 remote_ops
.to_can_do_single_step
= remote_can_do_single_step
;
13595 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
13596 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
13597 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
13598 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
13599 remote_ops
.to_supports_disable_randomization
13600 = remote_supports_disable_randomization
;
13601 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
13602 remote_ops
.to_fileio_open
= remote_hostio_open
;
13603 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
13604 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
13605 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
13606 remote_ops
.to_fileio_close
= remote_hostio_close
;
13607 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
13608 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
13609 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
13610 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
13611 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
13612 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
13613 remote_ops
.to_trace_init
= remote_trace_init
;
13614 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
13615 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
13616 remote_ops
.to_download_trace_state_variable
13617 = remote_download_trace_state_variable
;
13618 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
13619 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
13620 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
13621 remote_ops
.to_trace_start
= remote_trace_start
;
13622 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
13623 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
13624 remote_ops
.to_trace_stop
= remote_trace_stop
;
13625 remote_ops
.to_trace_find
= remote_trace_find
;
13626 remote_ops
.to_get_trace_state_variable_value
13627 = remote_get_trace_state_variable_value
;
13628 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
13629 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
13630 remote_ops
.to_upload_trace_state_variables
13631 = remote_upload_trace_state_variables
;
13632 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
13633 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
13634 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
13635 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
13636 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
13637 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
13638 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
13639 remote_ops
.to_verify_memory
= remote_verify_memory
;
13640 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
13641 remote_ops
.to_set_permissions
= remote_set_permissions
;
13642 remote_ops
.to_static_tracepoint_marker_at
13643 = remote_static_tracepoint_marker_at
;
13644 remote_ops
.to_static_tracepoint_markers_by_strid
13645 = remote_static_tracepoint_markers_by_strid
;
13646 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
13647 remote_ops
.to_use_agent
= remote_use_agent
;
13648 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
13649 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
13650 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
13651 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
13652 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
13653 remote_ops
.to_read_btrace
= remote_read_btrace
;
13654 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
13655 remote_ops
.to_augmented_libraries_svr4_read
=
13656 remote_augmented_libraries_svr4_read
;
13657 remote_ops
.to_follow_fork
= remote_follow_fork
;
13658 remote_ops
.to_follow_exec
= remote_follow_exec
;
13659 remote_ops
.to_insert_fork_catchpoint
= remote_insert_fork_catchpoint
;
13660 remote_ops
.to_remove_fork_catchpoint
= remote_remove_fork_catchpoint
;
13661 remote_ops
.to_insert_vfork_catchpoint
= remote_insert_vfork_catchpoint
;
13662 remote_ops
.to_remove_vfork_catchpoint
= remote_remove_vfork_catchpoint
;
13663 remote_ops
.to_insert_exec_catchpoint
= remote_insert_exec_catchpoint
;
13664 remote_ops
.to_remove_exec_catchpoint
= remote_remove_exec_catchpoint
;
13665 remote_ops
.to_execution_direction
= remote_execution_direction
;
13668 /* Set up the extended remote vector by making a copy of the standard
13669 remote vector and adding to it. */
13672 init_extended_remote_ops (void)
13674 extended_remote_ops
= remote_ops
;
13676 extended_remote_ops
.to_shortname
= "extended-remote";
13677 extended_remote_ops
.to_longname
=
13678 "Extended remote serial target in gdb-specific protocol";
13679 extended_remote_ops
.to_doc
=
13680 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13681 Specify the serial device it is connected to (e.g. /dev/ttya).";
13682 extended_remote_ops
.to_open
= extended_remote_open
;
13683 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
13684 extended_remote_ops
.to_detach
= extended_remote_detach
;
13685 extended_remote_ops
.to_attach
= extended_remote_attach
;
13686 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
13687 extended_remote_ops
.to_supports_disable_randomization
13688 = extended_remote_supports_disable_randomization
;
13692 remote_can_async_p (struct target_ops
*ops
)
13694 struct remote_state
*rs
= get_remote_state ();
13696 /* We don't go async if the user has explicitly prevented it with the
13697 "maint set target-async" command. */
13698 if (!target_async_permitted
)
13701 /* We're async whenever the serial device is. */
13702 return serial_can_async_p (rs
->remote_desc
);
13706 remote_is_async_p (struct target_ops
*ops
)
13708 struct remote_state
*rs
= get_remote_state ();
13710 if (!target_async_permitted
)
13711 /* We only enable async when the user specifically asks for it. */
13714 /* We're async whenever the serial device is. */
13715 return serial_is_async_p (rs
->remote_desc
);
13718 /* Pass the SERIAL event on and up to the client. One day this code
13719 will be able to delay notifying the client of an event until the
13720 point where an entire packet has been received. */
13722 static serial_event_ftype remote_async_serial_handler
;
13725 remote_async_serial_handler (struct serial
*scb
, void *context
)
13727 /* Don't propogate error information up to the client. Instead let
13728 the client find out about the error by querying the target. */
13729 inferior_event_handler (INF_REG_EVENT
, NULL
);
13733 remote_async_inferior_event_handler (gdb_client_data data
)
13735 inferior_event_handler (INF_REG_EVENT
, NULL
);
13739 remote_async (struct target_ops
*ops
, int enable
)
13741 struct remote_state
*rs
= get_remote_state ();
13745 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
13747 /* If there are pending events in the stop reply queue tell the
13748 event loop to process them. */
13749 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
13750 mark_async_event_handler (remote_async_inferior_event_token
);
13751 /* For simplicity, below we clear the pending events token
13752 without remembering whether it is marked, so here we always
13753 mark it. If there's actually no pending notification to
13754 process, this ends up being a no-op (other than a spurious
13755 event-loop wakeup). */
13756 if (target_is_non_stop_p ())
13757 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13761 serial_async (rs
->remote_desc
, NULL
, NULL
);
13762 /* If the core is disabling async, it doesn't want to be
13763 disturbed with target events. Clear all async event sources
13765 clear_async_event_handler (remote_async_inferior_event_token
);
13766 if (target_is_non_stop_p ())
13767 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13771 /* Implementation of the to_thread_events method. */
13774 remote_thread_events (struct target_ops
*ops
, int enable
)
13776 struct remote_state
*rs
= get_remote_state ();
13777 size_t size
= get_remote_packet_size ();
13779 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
13782 xsnprintf (rs
->buf
, size
, "QThreadEvents:%x", enable
? 1 : 0);
13784 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13786 switch (packet_ok (rs
->buf
,
13787 &remote_protocol_packets
[PACKET_QThreadEvents
]))
13790 if (strcmp (rs
->buf
, "OK") != 0)
13791 error (_("Remote refused setting thread events: %s"), rs
->buf
);
13794 warning (_("Remote failure reply: %s"), rs
->buf
);
13796 case PACKET_UNKNOWN
:
13802 set_remote_cmd (char *args
, int from_tty
)
13804 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
13808 show_remote_cmd (char *args
, int from_tty
)
13810 /* We can't just use cmd_show_list here, because we want to skip
13811 the redundant "show remote Z-packet" and the legacy aliases. */
13812 struct cmd_list_element
*list
= remote_show_cmdlist
;
13813 struct ui_out
*uiout
= current_uiout
;
13815 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
13816 for (; list
!= NULL
; list
= list
->next
)
13817 if (strcmp (list
->name
, "Z-packet") == 0)
13819 else if (list
->type
== not_set_cmd
)
13820 /* Alias commands are exactly like the original, except they
13821 don't have the normal type. */
13825 ui_out_emit_tuple
option_emitter (uiout
, "option");
13827 uiout
->field_string ("name", list
->name
);
13828 uiout
->text (": ");
13829 if (list
->type
== show_cmd
)
13830 do_show_command (NULL
, from_tty
, list
);
13832 cmd_func (list
, NULL
, from_tty
);
13837 /* Function to be called whenever a new objfile (shlib) is detected. */
13839 remote_new_objfile (struct objfile
*objfile
)
13841 struct remote_state
*rs
= get_remote_state ();
13843 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
13844 remote_check_symbols ();
13847 /* Pull all the tracepoints defined on the target and create local
13848 data structures representing them. We don't want to create real
13849 tracepoints yet, we don't want to mess up the user's existing
13853 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
13855 struct remote_state
*rs
= get_remote_state ();
13858 /* Ask for a first packet of tracepoint definition. */
13860 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13862 while (*p
&& *p
!= 'l')
13864 parse_tracepoint_definition (p
, utpp
);
13865 /* Ask for another packet of tracepoint definition. */
13867 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13874 remote_upload_trace_state_variables (struct target_ops
*self
,
13875 struct uploaded_tsv
**utsvp
)
13877 struct remote_state
*rs
= get_remote_state ();
13880 /* Ask for a first packet of variable definition. */
13882 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13884 while (*p
&& *p
!= 'l')
13886 parse_tsv_definition (p
, utsvp
);
13887 /* Ask for another packet of variable definition. */
13889 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13895 /* The "set/show range-stepping" show hook. */
13898 show_range_stepping (struct ui_file
*file
, int from_tty
,
13899 struct cmd_list_element
*c
,
13902 fprintf_filtered (file
,
13903 _("Debugger's willingness to use range stepping "
13904 "is %s.\n"), value
);
13907 /* The "set/show range-stepping" set hook. */
13910 set_range_stepping (char *ignore_args
, int from_tty
,
13911 struct cmd_list_element
*c
)
13913 struct remote_state
*rs
= get_remote_state ();
13915 /* Whene enabling, check whether range stepping is actually
13916 supported by the target, and warn if not. */
13917 if (use_range_stepping
)
13919 if (rs
->remote_desc
!= NULL
)
13921 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13922 remote_vcont_probe (rs
);
13924 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
13925 && rs
->supports_vCont
.r
)
13929 warning (_("Range stepping is not supported by the current target"));
13934 _initialize_remote (void)
13936 struct cmd_list_element
*cmd
;
13937 const char *cmd_name
;
13939 /* architecture specific data */
13940 remote_gdbarch_data_handle
=
13941 gdbarch_data_register_post_init (init_remote_state
);
13942 remote_g_packet_data_handle
=
13943 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
13946 = register_program_space_data_with_cleanup (NULL
,
13947 remote_pspace_data_cleanup
);
13949 /* Initialize the per-target state. At the moment there is only one
13950 of these, not one per target. Only one target is active at a
13952 remote_state
= new_remote_state ();
13954 init_remote_ops ();
13955 add_target (&remote_ops
);
13957 init_extended_remote_ops ();
13958 add_target (&extended_remote_ops
);
13960 /* Hook into new objfile notification. */
13961 observer_attach_new_objfile (remote_new_objfile
);
13962 /* We're no longer interested in notification events of an inferior
13964 observer_attach_inferior_exit (discard_pending_stop_replies
);
13967 init_remote_threadtests ();
13970 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
13971 /* set/show remote ... */
13973 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
13974 Remote protocol specific variables\n\
13975 Configure various remote-protocol specific variables such as\n\
13976 the packets being used"),
13977 &remote_set_cmdlist
, "set remote ",
13978 0 /* allow-unknown */, &setlist
);
13979 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
13980 Remote protocol specific variables\n\
13981 Configure various remote-protocol specific variables such as\n\
13982 the packets being used"),
13983 &remote_show_cmdlist
, "show remote ",
13984 0 /* allow-unknown */, &showlist
);
13986 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
13987 Compare section data on target to the exec file.\n\
13988 Argument is a single section name (default: all loaded sections).\n\
13989 To compare only read-only loaded sections, specify the -r option."),
13992 add_cmd ("packet", class_maintenance
, packet_command
, _("\
13993 Send an arbitrary packet to a remote target.\n\
13994 maintenance packet TEXT\n\
13995 If GDB is talking to an inferior via the GDB serial protocol, then\n\
13996 this command sends the string TEXT to the inferior, and displays the\n\
13997 response packet. GDB supplies the initial `$' character, and the\n\
13998 terminating `#' character and checksum."),
14001 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14002 Set whether to send break if interrupted."), _("\
14003 Show whether to send break if interrupted."), _("\
14004 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14005 set_remotebreak
, show_remotebreak
,
14006 &setlist
, &showlist
);
14007 cmd_name
= "remotebreak";
14008 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14009 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14010 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14011 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14012 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14014 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14015 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14017 Set interrupt sequence to remote target."), _("\
14018 Show interrupt sequence to remote target."), _("\
14019 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14020 NULL
, show_interrupt_sequence
,
14021 &remote_set_cmdlist
,
14022 &remote_show_cmdlist
);
14024 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14025 &interrupt_on_connect
, _("\
14026 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14027 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14028 If set, interrupt sequence is sent to remote target."),
14030 &remote_set_cmdlist
, &remote_show_cmdlist
);
14032 /* Install commands for configuring memory read/write packets. */
14034 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14035 Set the maximum number of bytes per memory write packet (deprecated)."),
14037 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14038 Show the maximum number of bytes per memory write packet (deprecated)."),
14040 add_cmd ("memory-write-packet-size", no_class
,
14041 set_memory_write_packet_size
, _("\
14042 Set the maximum number of bytes per memory-write packet.\n\
14043 Specify the number of bytes in a packet or 0 (zero) for the\n\
14044 default packet size. The actual limit is further reduced\n\
14045 dependent on the target. Specify ``fixed'' to disable the\n\
14046 further restriction and ``limit'' to enable that restriction."),
14047 &remote_set_cmdlist
);
14048 add_cmd ("memory-read-packet-size", no_class
,
14049 set_memory_read_packet_size
, _("\
14050 Set the maximum number of bytes per memory-read packet.\n\
14051 Specify the number of bytes in a packet or 0 (zero) for the\n\
14052 default packet size. The actual limit is further reduced\n\
14053 dependent on the target. Specify ``fixed'' to disable the\n\
14054 further restriction and ``limit'' to enable that restriction."),
14055 &remote_set_cmdlist
);
14056 add_cmd ("memory-write-packet-size", no_class
,
14057 show_memory_write_packet_size
,
14058 _("Show the maximum number of bytes per memory-write packet."),
14059 &remote_show_cmdlist
);
14060 add_cmd ("memory-read-packet-size", no_class
,
14061 show_memory_read_packet_size
,
14062 _("Show the maximum number of bytes per memory-read packet."),
14063 &remote_show_cmdlist
);
14065 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
14066 &remote_hw_watchpoint_limit
, _("\
14067 Set the maximum number of target hardware watchpoints."), _("\
14068 Show the maximum number of target hardware watchpoints."), _("\
14069 Specify a negative limit for unlimited."),
14070 NULL
, NULL
, /* FIXME: i18n: The maximum
14071 number of target hardware
14072 watchpoints is %s. */
14073 &remote_set_cmdlist
, &remote_show_cmdlist
);
14074 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
14075 &remote_hw_watchpoint_length_limit
, _("\
14076 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14077 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14078 Specify a negative limit for unlimited."),
14079 NULL
, NULL
, /* FIXME: i18n: The maximum
14080 length (in bytes) of a target
14081 hardware watchpoint is %s. */
14082 &remote_set_cmdlist
, &remote_show_cmdlist
);
14083 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
14084 &remote_hw_breakpoint_limit
, _("\
14085 Set the maximum number of target hardware breakpoints."), _("\
14086 Show the maximum number of target hardware breakpoints."), _("\
14087 Specify a negative limit for unlimited."),
14088 NULL
, NULL
, /* FIXME: i18n: The maximum
14089 number of target hardware
14090 breakpoints is %s. */
14091 &remote_set_cmdlist
, &remote_show_cmdlist
);
14093 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14094 &remote_address_size
, _("\
14095 Set the maximum size of the address (in bits) in a memory packet."), _("\
14096 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14098 NULL
, /* FIXME: i18n: */
14099 &setlist
, &showlist
);
14101 init_all_packet_configs ();
14103 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14104 "X", "binary-download", 1);
14106 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14107 "vCont", "verbose-resume", 0);
14109 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14110 "QPassSignals", "pass-signals", 0);
14112 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14113 "QCatchSyscalls", "catch-syscalls", 0);
14115 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14116 "QProgramSignals", "program-signals", 0);
14118 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14119 "QStartupWithShell", "startup-with-shell", 0);
14121 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14122 "qSymbol", "symbol-lookup", 0);
14124 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14125 "P", "set-register", 1);
14127 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14128 "p", "fetch-register", 1);
14130 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14131 "Z0", "software-breakpoint", 0);
14133 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14134 "Z1", "hardware-breakpoint", 0);
14136 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14137 "Z2", "write-watchpoint", 0);
14139 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14140 "Z3", "read-watchpoint", 0);
14142 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14143 "Z4", "access-watchpoint", 0);
14145 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14146 "qXfer:auxv:read", "read-aux-vector", 0);
14148 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14149 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14151 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14152 "qXfer:features:read", "target-features", 0);
14154 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14155 "qXfer:libraries:read", "library-info", 0);
14157 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14158 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14160 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14161 "qXfer:memory-map:read", "memory-map", 0);
14163 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14164 "qXfer:spu:read", "read-spu-object", 0);
14166 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14167 "qXfer:spu:write", "write-spu-object", 0);
14169 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14170 "qXfer:osdata:read", "osdata", 0);
14172 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14173 "qXfer:threads:read", "threads", 0);
14175 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14176 "qXfer:siginfo:read", "read-siginfo-object", 0);
14178 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14179 "qXfer:siginfo:write", "write-siginfo-object", 0);
14181 add_packet_config_cmd
14182 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14183 "qXfer:traceframe-info:read", "traceframe-info", 0);
14185 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14186 "qXfer:uib:read", "unwind-info-block", 0);
14188 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14189 "qGetTLSAddr", "get-thread-local-storage-address",
14192 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14193 "qGetTIBAddr", "get-thread-information-block-address",
14196 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14197 "bc", "reverse-continue", 0);
14199 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14200 "bs", "reverse-step", 0);
14202 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14203 "qSupported", "supported-packets", 0);
14205 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14206 "qSearch:memory", "search-memory", 0);
14208 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14209 "qTStatus", "trace-status", 0);
14211 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14212 "vFile:setfs", "hostio-setfs", 0);
14214 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14215 "vFile:open", "hostio-open", 0);
14217 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14218 "vFile:pread", "hostio-pread", 0);
14220 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14221 "vFile:pwrite", "hostio-pwrite", 0);
14223 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14224 "vFile:close", "hostio-close", 0);
14226 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14227 "vFile:unlink", "hostio-unlink", 0);
14229 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14230 "vFile:readlink", "hostio-readlink", 0);
14232 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14233 "vFile:fstat", "hostio-fstat", 0);
14235 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14236 "vAttach", "attach", 0);
14238 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14241 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14242 "QStartNoAckMode", "noack", 0);
14244 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14245 "vKill", "kill", 0);
14247 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14248 "qAttached", "query-attached", 0);
14250 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14251 "ConditionalTracepoints",
14252 "conditional-tracepoints", 0);
14254 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14255 "ConditionalBreakpoints",
14256 "conditional-breakpoints", 0);
14258 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14259 "BreakpointCommands",
14260 "breakpoint-commands", 0);
14262 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14263 "FastTracepoints", "fast-tracepoints", 0);
14265 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14266 "TracepointSource", "TracepointSource", 0);
14268 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14269 "QAllow", "allow", 0);
14271 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14272 "StaticTracepoints", "static-tracepoints", 0);
14274 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14275 "InstallInTrace", "install-in-trace", 0);
14277 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14278 "qXfer:statictrace:read", "read-sdata-object", 0);
14280 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14281 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14283 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14284 "QDisableRandomization", "disable-randomization", 0);
14286 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14287 "QAgent", "agent", 0);
14289 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14290 "QTBuffer:size", "trace-buffer-size", 0);
14292 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14293 "Qbtrace:off", "disable-btrace", 0);
14295 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14296 "Qbtrace:bts", "enable-btrace-bts", 0);
14298 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14299 "Qbtrace:pt", "enable-btrace-pt", 0);
14301 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14302 "qXfer:btrace", "read-btrace", 0);
14304 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14305 "qXfer:btrace-conf", "read-btrace-conf", 0);
14307 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14308 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14310 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14311 "multiprocess-feature", "multiprocess-feature", 0);
14313 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14314 "swbreak-feature", "swbreak-feature", 0);
14316 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14317 "hwbreak-feature", "hwbreak-feature", 0);
14319 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14320 "fork-event-feature", "fork-event-feature", 0);
14322 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14323 "vfork-event-feature", "vfork-event-feature", 0);
14325 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14326 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14328 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14329 "vContSupported", "verbose-resume-supported", 0);
14331 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14332 "exec-event-feature", "exec-event-feature", 0);
14334 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14335 "vCtrlC", "ctrl-c", 0);
14337 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14338 "QThreadEvents", "thread-events", 0);
14340 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14341 "N stop reply", "no-resumed-stop-reply", 0);
14343 /* Assert that we've registered "set remote foo-packet" commands
14344 for all packet configs. */
14348 for (i
= 0; i
< PACKET_MAX
; i
++)
14350 /* Ideally all configs would have a command associated. Some
14351 still don't though. */
14356 case PACKET_QNonStop
:
14357 case PACKET_EnableDisableTracepoints_feature
:
14358 case PACKET_tracenz_feature
:
14359 case PACKET_DisconnectedTracing_feature
:
14360 case PACKET_augmented_libraries_svr4_read_feature
:
14362 /* Additions to this list need to be well justified:
14363 pre-existing packets are OK; new packets are not. */
14371 /* This catches both forgetting to add a config command, and
14372 forgetting to remove a packet from the exception list. */
14373 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14377 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14378 Z sub-packet has its own set and show commands, but users may
14379 have sets to this variable in their .gdbinit files (or in their
14381 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14382 &remote_Z_packet_detect
, _("\
14383 Set use of remote protocol `Z' packets"), _("\
14384 Show use of remote protocol `Z' packets "), _("\
14385 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14387 set_remote_protocol_Z_packet_cmd
,
14388 show_remote_protocol_Z_packet_cmd
,
14389 /* FIXME: i18n: Use of remote protocol
14390 `Z' packets is %s. */
14391 &remote_set_cmdlist
, &remote_show_cmdlist
);
14393 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14394 Manipulate files on the remote system\n\
14395 Transfer files to and from the remote target system."),
14396 &remote_cmdlist
, "remote ",
14397 0 /* allow-unknown */, &cmdlist
);
14399 add_cmd ("put", class_files
, remote_put_command
,
14400 _("Copy a local file to the remote system."),
14403 add_cmd ("get", class_files
, remote_get_command
,
14404 _("Copy a remote file to the local system."),
14407 add_cmd ("delete", class_files
, remote_delete_command
,
14408 _("Delete a remote file."),
14411 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14412 &remote_exec_file_var
, _("\
14413 Set the remote pathname for \"run\""), _("\
14414 Show the remote pathname for \"run\""), NULL
,
14415 set_remote_exec_file
,
14416 show_remote_exec_file
,
14417 &remote_set_cmdlist
,
14418 &remote_show_cmdlist
);
14420 add_setshow_boolean_cmd ("range-stepping", class_run
,
14421 &use_range_stepping
, _("\
14422 Enable or disable range stepping."), _("\
14423 Show whether target-assisted range stepping is enabled."), _("\
14424 If on, and the target supports it, when stepping a source line, GDB\n\
14425 tells the target to step the corresponding range of addresses itself instead\n\
14426 of issuing multiple single-steps. This speeds up source level\n\
14427 stepping. If off, GDB always issues single-steps, even if range\n\
14428 stepping is supported by the target. The default is on."),
14429 set_range_stepping
,
14430 show_range_stepping
,
14434 /* Eventually initialize fileio. See fileio.c */
14435 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
14437 /* Take advantage of the fact that the TID field is not used, to tag
14438 special ptids with it set to != 0. */
14439 magic_null_ptid
= ptid_build (42000, -1, 1);
14440 not_sent_ptid
= ptid_build (42000, -2, 1);
14441 any_thread_ptid
= ptid_build (42000, 0, 1);
14443 target_buf_size
= 2048;
14444 target_buf
= (char *) xmalloc (target_buf_size
);