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 typedef struct cached_reg
6320 DEF_VEC_O(cached_reg_t
);
6322 typedef struct stop_reply
6324 struct notif_event base
;
6326 /* The identifier of the thread about this event */
6329 /* The remote state this event is associated with. When the remote
6330 connection, represented by a remote_state object, is closed,
6331 all the associated stop_reply events should be released. */
6332 struct remote_state
*rs
;
6334 struct target_waitstatus ws
;
6336 /* Expedited registers. This makes remote debugging a bit more
6337 efficient for those targets that provide critical registers as
6338 part of their normal status mechanism (as another roundtrip to
6339 fetch them is avoided). */
6340 VEC(cached_reg_t
) *regcache
;
6342 enum target_stop_reason stop_reason
;
6344 CORE_ADDR watch_data_address
;
6349 DECLARE_QUEUE_P (stop_reply_p
);
6350 DEFINE_QUEUE_P (stop_reply_p
);
6351 /* The list of already fetched and acknowledged stop events. This
6352 queue is used for notification Stop, and other notifications
6353 don't need queue for their events, because the notification events
6354 of Stop can't be consumed immediately, so that events should be
6355 queued first, and be consumed by remote_wait_{ns,as} one per
6356 time. Other notifications can consume their events immediately,
6357 so queue is not needed for them. */
6358 static QUEUE (stop_reply_p
) *stop_reply_queue
;
6361 stop_reply_xfree (struct stop_reply
*r
)
6363 notif_event_xfree ((struct notif_event
*) r
);
6366 /* Return the length of the stop reply queue. */
6369 stop_reply_queue_length (void)
6371 return QUEUE_length (stop_reply_p
, stop_reply_queue
);
6375 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
6376 struct notif_event
*event
)
6378 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6382 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
6383 struct notif_event
*event
)
6385 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6388 putpkt (self
->ack_command
);
6390 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6391 /* We got an unknown stop reply. */
6392 error (_("Unknown stop reply"));
6394 push_stop_reply (stop_reply
);
6398 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
6400 /* We can't get pending events in remote_notif_process for
6401 notification stop, and we have to do this in remote_wait_ns
6402 instead. If we fetch all queued events from stub, remote stub
6403 may exit and we have no chance to process them back in
6405 mark_async_event_handler (remote_async_inferior_event_token
);
6410 stop_reply_dtr (struct notif_event
*event
)
6412 struct stop_reply
*r
= (struct stop_reply
*) event
;
6417 VEC_iterate (cached_reg_t
, r
->regcache
, ix
, reg
);
6421 VEC_free (cached_reg_t
, r
->regcache
);
6424 static struct notif_event
*
6425 remote_notif_stop_alloc_reply (void)
6427 /* We cast to a pointer to the "base class". */
6428 struct notif_event
*r
= (struct notif_event
*) XNEW (struct stop_reply
);
6430 r
->dtr
= stop_reply_dtr
;
6435 /* A client of notification Stop. */
6437 struct notif_client notif_client_stop
=
6441 remote_notif_stop_parse
,
6442 remote_notif_stop_ack
,
6443 remote_notif_stop_can_get_pending_events
,
6444 remote_notif_stop_alloc_reply
,
6448 /* A parameter to pass data in and out. */
6450 struct queue_iter_param
6453 struct stop_reply
*output
;
6456 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6457 the pid of the process that owns the threads we want to check, or
6458 -1 if we want to check all threads. */
6461 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6464 if (ws
->kind
== TARGET_WAITKIND_FORKED
6465 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6467 if (event_pid
== -1 || event_pid
== ptid_get_pid (thread_ptid
))
6474 /* Return the thread's pending status used to determine whether the
6475 thread is a fork parent stopped at a fork event. */
6477 static struct target_waitstatus
*
6478 thread_pending_fork_status (struct thread_info
*thread
)
6480 if (thread
->suspend
.waitstatus_pending_p
)
6481 return &thread
->suspend
.waitstatus
;
6483 return &thread
->pending_follow
;
6486 /* Determine if THREAD is a pending fork parent thread. */
6489 is_pending_fork_parent_thread (struct thread_info
*thread
)
6491 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6494 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6497 /* Check whether EVENT is a fork event, and if it is, remove the
6498 fork child from the context list passed in DATA. */
6501 remove_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
6502 QUEUE_ITER (stop_reply_p
) *iter
,
6506 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6507 struct threads_listing_context
*context
6508 = (struct threads_listing_context
*) param
->input
;
6510 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6511 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6512 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6513 threads_listing_context_remove (&event
->ws
, context
);
6518 /* If CONTEXT contains any fork child threads that have not been
6519 reported yet, remove them from the CONTEXT list. If such a
6520 thread exists it is because we are stopped at a fork catchpoint
6521 and have not yet called follow_fork, which will set up the
6522 host-side data structures for the new process. */
6525 remove_new_fork_children (struct threads_listing_context
*context
)
6527 struct thread_info
* thread
;
6529 struct notif_client
*notif
= ¬if_client_stop
;
6530 struct queue_iter_param param
;
6532 /* For any threads stopped at a fork event, remove the corresponding
6533 fork child threads from the CONTEXT list. */
6534 ALL_NON_EXITED_THREADS (thread
)
6536 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6538 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6540 threads_listing_context_remove (ws
, context
);
6544 /* Check for any pending fork events (not reported or processed yet)
6545 in process PID and remove those fork child threads from the
6546 CONTEXT list as well. */
6547 remote_notif_get_pending_events (notif
);
6548 param
.input
= context
;
6549 param
.output
= NULL
;
6550 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6551 remove_child_of_pending_fork
, ¶m
);
6554 /* Check whether EVENT would prevent a global or process wildcard
6558 check_pending_event_prevents_wildcard_vcont_callback
6559 (QUEUE (stop_reply_p
) *q
,
6560 QUEUE_ITER (stop_reply_p
) *iter
,
6564 struct inferior
*inf
;
6565 int *may_global_wildcard_vcont
= (int *) data
;
6567 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6568 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6571 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6572 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6573 *may_global_wildcard_vcont
= 0;
6575 inf
= find_inferior_ptid (event
->ptid
);
6577 /* This may be the first time we heard about this process.
6578 Regardless, we must not do a global wildcard resume, otherwise
6579 we'd resume this process too. */
6580 *may_global_wildcard_vcont
= 0;
6582 inf
->priv
->may_wildcard_vcont
= 0;
6587 /* Check whether any event pending in the vStopped queue would prevent
6588 a global or process wildcard vCont action. Clear
6589 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6590 and clear the event inferior's may_wildcard_vcont flag if we can't
6591 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6594 check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard
)
6596 struct notif_client
*notif
= ¬if_client_stop
;
6598 remote_notif_get_pending_events (notif
);
6599 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6600 check_pending_event_prevents_wildcard_vcont_callback
,
6601 may_global_wildcard
);
6604 /* Remove stop replies in the queue if its pid is equal to the given
6608 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
6609 QUEUE_ITER (stop_reply_p
) *iter
,
6613 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6614 struct inferior
*inf
= (struct inferior
*) param
->input
;
6616 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
6618 stop_reply_xfree (event
);
6619 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6625 /* Discard all pending stop replies of inferior INF. */
6628 discard_pending_stop_replies (struct inferior
*inf
)
6630 struct queue_iter_param param
;
6631 struct stop_reply
*reply
;
6632 struct remote_state
*rs
= get_remote_state ();
6633 struct remote_notif_state
*rns
= rs
->notif_state
;
6635 /* This function can be notified when an inferior exists. When the
6636 target is not remote, the notification state is NULL. */
6637 if (rs
->remote_desc
== NULL
)
6640 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
6642 /* Discard the in-flight notification. */
6643 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
6645 stop_reply_xfree (reply
);
6646 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
6650 param
.output
= NULL
;
6651 /* Discard the stop replies we have already pulled with
6653 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6654 remove_stop_reply_for_inferior
, ¶m
);
6657 /* If its remote state is equal to the given remote state,
6658 remove EVENT from the stop reply queue. */
6661 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
6662 QUEUE_ITER (stop_reply_p
) *iter
,
6666 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6667 struct remote_state
*rs
= (struct remote_state
*) param
->input
;
6669 if (event
->rs
== rs
)
6671 stop_reply_xfree (event
);
6672 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6678 /* Discard the stop replies for RS in stop_reply_queue. */
6681 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
6683 struct queue_iter_param param
;
6686 param
.output
= NULL
;
6687 /* Discard the stop replies we have already pulled with
6689 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6690 remove_stop_reply_of_remote_state
, ¶m
);
6693 /* A parameter to pass data in and out. */
6696 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
6697 QUEUE_ITER (stop_reply_p
) *iter
,
6701 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6702 ptid_t
*ptid
= (ptid_t
*) param
->input
;
6704 if (ptid_match (event
->ptid
, *ptid
))
6706 param
->output
= event
;
6707 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6714 /* Remove the first reply in 'stop_reply_queue' which matches
6717 static struct stop_reply
*
6718 remote_notif_remove_queued_reply (ptid_t ptid
)
6720 struct queue_iter_param param
;
6722 param
.input
= &ptid
;
6723 param
.output
= NULL
;
6725 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6726 remote_notif_remove_once_on_match
, ¶m
);
6728 fprintf_unfiltered (gdb_stdlog
,
6729 "notif: discard queued event: 'Stop' in %s\n",
6730 target_pid_to_str (ptid
));
6732 return param
.output
;
6735 /* Look for a queued stop reply belonging to PTID. If one is found,
6736 remove it from the queue, and return it. Returns NULL if none is
6737 found. If there are still queued events left to process, tell the
6738 event loop to get back to target_wait soon. */
6740 static struct stop_reply
*
6741 queued_stop_reply (ptid_t ptid
)
6743 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
6745 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6746 /* There's still at least an event left. */
6747 mark_async_event_handler (remote_async_inferior_event_token
);
6752 /* Push a fully parsed stop reply in the stop reply queue. Since we
6753 know that we now have at least one queued event left to pass to the
6754 core side, tell the event loop to get back to target_wait soon. */
6757 push_stop_reply (struct stop_reply
*new_event
)
6759 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
6762 fprintf_unfiltered (gdb_stdlog
,
6763 "notif: push 'Stop' %s to queue %d\n",
6764 target_pid_to_str (new_event
->ptid
),
6765 QUEUE_length (stop_reply_p
,
6768 mark_async_event_handler (remote_async_inferior_event_token
);
6772 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
6773 QUEUE_ITER (stop_reply_p
) *iter
,
6774 struct stop_reply
*event
,
6777 ptid_t
*ptid
= (ptid_t
*) data
;
6779 return !(ptid_equal (*ptid
, event
->ptid
)
6780 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
6783 /* Returns true if we have a stop reply for PTID. */
6786 peek_stop_reply (ptid_t ptid
)
6788 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6789 stop_reply_match_ptid_and_ws
, &ptid
);
6792 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
6793 starting with P and ending with PEND matches PREFIX. */
6796 strprefix (const char *p
, const char *pend
, const char *prefix
)
6798 for ( ; p
< pend
; p
++, prefix
++)
6801 return *prefix
== '\0';
6804 /* Parse the stop reply in BUF. Either the function succeeds, and the
6805 result is stored in EVENT, or throws an error. */
6808 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
6810 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6815 event
->ptid
= null_ptid
;
6816 event
->rs
= get_remote_state ();
6817 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
6818 event
->ws
.value
.integer
= 0;
6819 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6820 event
->regcache
= NULL
;
6825 case 'T': /* Status with PC, SP, FP, ... */
6826 /* Expedited reply, containing Signal, {regno, reg} repeat. */
6827 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
6829 n... = register number
6830 r... = register contents
6833 p
= &buf
[3]; /* after Txx */
6839 p1
= strchr (p
, ':');
6841 error (_("Malformed packet(a) (missing colon): %s\n\
6845 error (_("Malformed packet(a) (missing register number): %s\n\
6849 /* Some "registers" are actually extended stop information.
6850 Note if you're adding a new entry here: GDB 7.9 and
6851 earlier assume that all register "numbers" that start
6852 with an hex digit are real register numbers. Make sure
6853 the server only sends such a packet if it knows the
6854 client understands it. */
6856 if (strprefix (p
, p1
, "thread"))
6857 event
->ptid
= read_ptid (++p1
, &p
);
6858 else if (strprefix (p
, p1
, "syscall_entry"))
6862 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
6863 p
= unpack_varlen_hex (++p1
, &sysno
);
6864 event
->ws
.value
.syscall_number
= (int) sysno
;
6866 else if (strprefix (p
, p1
, "syscall_return"))
6870 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
6871 p
= unpack_varlen_hex (++p1
, &sysno
);
6872 event
->ws
.value
.syscall_number
= (int) sysno
;
6874 else if (strprefix (p
, p1
, "watch")
6875 || strprefix (p
, p1
, "rwatch")
6876 || strprefix (p
, p1
, "awatch"))
6878 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
6879 p
= unpack_varlen_hex (++p1
, &addr
);
6880 event
->watch_data_address
= (CORE_ADDR
) addr
;
6882 else if (strprefix (p
, p1
, "swbreak"))
6884 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
6886 /* Make sure the stub doesn't forget to indicate support
6888 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
6889 error (_("Unexpected swbreak stop reason"));
6891 /* The value part is documented as "must be empty",
6892 though we ignore it, in case we ever decide to make
6893 use of it in a backward compatible way. */
6894 p
= strchrnul (p1
+ 1, ';');
6896 else if (strprefix (p
, p1
, "hwbreak"))
6898 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
6900 /* Make sure the stub doesn't forget to indicate support
6902 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
6903 error (_("Unexpected hwbreak stop reason"));
6906 p
= strchrnul (p1
+ 1, ';');
6908 else if (strprefix (p
, p1
, "library"))
6910 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
6911 p
= strchrnul (p1
+ 1, ';');
6913 else if (strprefix (p
, p1
, "replaylog"))
6915 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
6916 /* p1 will indicate "begin" or "end", but it makes
6917 no difference for now, so ignore it. */
6918 p
= strchrnul (p1
+ 1, ';');
6920 else if (strprefix (p
, p1
, "core"))
6924 p
= unpack_varlen_hex (++p1
, &c
);
6927 else if (strprefix (p
, p1
, "fork"))
6929 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6930 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
6932 else if (strprefix (p
, p1
, "vfork"))
6934 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6935 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
6937 else if (strprefix (p
, p1
, "vforkdone"))
6939 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
6940 p
= strchrnul (p1
+ 1, ';');
6942 else if (strprefix (p
, p1
, "exec"))
6945 char pathname
[PATH_MAX
];
6948 /* Determine the length of the execd pathname. */
6949 p
= unpack_varlen_hex (++p1
, &ignored
);
6950 pathlen
= (p
- p1
) / 2;
6952 /* Save the pathname for event reporting and for
6953 the next run command. */
6954 hex2bin (p1
, (gdb_byte
*) pathname
, pathlen
);
6955 pathname
[pathlen
] = '\0';
6957 /* This is freed during event handling. */
6958 event
->ws
.value
.execd_pathname
= xstrdup (pathname
);
6959 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
6961 /* Skip the registers included in this packet, since
6962 they may be for an architecture different from the
6963 one used by the original program. */
6966 else if (strprefix (p
, p1
, "create"))
6968 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
6969 p
= strchrnul (p1
+ 1, ';');
6978 p
= strchrnul (p1
+ 1, ';');
6983 /* Maybe a real ``P'' register number. */
6984 p_temp
= unpack_varlen_hex (p
, &pnum
);
6985 /* If the first invalid character is the colon, we got a
6986 register number. Otherwise, it's an unknown stop
6990 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
6991 cached_reg_t cached_reg
;
6992 struct gdbarch
*gdbarch
= target_gdbarch ();
6995 error (_("Remote sent bad register number %s: %s\n\
6997 hex_string (pnum
), p
, buf
);
6999 cached_reg
.num
= reg
->regnum
;
7000 cached_reg
.data
= (gdb_byte
*)
7001 xmalloc (register_size (gdbarch
, reg
->regnum
));
7004 fieldsize
= hex2bin (p
, cached_reg
.data
,
7005 register_size (gdbarch
, reg
->regnum
));
7007 if (fieldsize
< register_size (gdbarch
, reg
->regnum
))
7008 warning (_("Remote reply is too short: %s"), buf
);
7010 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
7014 /* Not a number. Silently skip unknown optional
7016 p
= strchrnul (p1
+ 1, ';');
7021 error (_("Remote register badly formatted: %s\nhere: %s"),
7026 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7030 case 'S': /* Old style status, just signal only. */
7034 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7035 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7036 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7037 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7039 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7042 case 'w': /* Thread exited. */
7047 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7048 p
= unpack_varlen_hex (&buf
[1], &value
);
7049 event
->ws
.value
.integer
= value
;
7051 error (_("stop reply packet badly formatted: %s"), buf
);
7052 event
->ptid
= read_ptid (++p
, NULL
);
7055 case 'W': /* Target exited. */
7062 /* GDB used to accept only 2 hex chars here. Stubs should
7063 only send more if they detect GDB supports multi-process
7065 p
= unpack_varlen_hex (&buf
[1], &value
);
7069 /* The remote process exited. */
7070 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7071 event
->ws
.value
.integer
= value
;
7075 /* The remote process exited with a signal. */
7076 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7077 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7078 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7080 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7083 /* If no process is specified, assume inferior_ptid. */
7084 pid
= ptid_get_pid (inferior_ptid
);
7093 else if (startswith (p
, "process:"))
7097 p
+= sizeof ("process:") - 1;
7098 unpack_varlen_hex (p
, &upid
);
7102 error (_("unknown stop reply packet: %s"), buf
);
7105 error (_("unknown stop reply packet: %s"), buf
);
7106 event
->ptid
= pid_to_ptid (pid
);
7110 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7111 event
->ptid
= minus_one_ptid
;
7115 if (target_is_non_stop_p () && ptid_equal (event
->ptid
, null_ptid
))
7116 error (_("No process or thread specified in stop reply: %s"), buf
);
7119 /* When the stub wants to tell GDB about a new notification reply, it
7120 sends a notification (%Stop, for example). Those can come it at
7121 any time, hence, we have to make sure that any pending
7122 putpkt/getpkt sequence we're making is finished, before querying
7123 the stub for more events with the corresponding ack command
7124 (vStopped, for example). E.g., if we started a vStopped sequence
7125 immediately upon receiving the notification, something like this
7133 1.6) <-- (registers reply to step #1.3)
7135 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7138 To solve this, whenever we parse a %Stop notification successfully,
7139 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7140 doing whatever we were doing:
7146 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7147 2.5) <-- (registers reply to step #2.3)
7149 Eventualy after step #2.5, we return to the event loop, which
7150 notices there's an event on the
7151 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7152 associated callback --- the function below. At this point, we're
7153 always safe to start a vStopped sequence. :
7156 2.7) <-- T05 thread:2
7162 remote_notif_get_pending_events (struct notif_client
*nc
)
7164 struct remote_state
*rs
= get_remote_state ();
7166 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7169 fprintf_unfiltered (gdb_stdlog
,
7170 "notif: process: '%s' ack pending event\n",
7174 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
7175 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7179 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7180 if (strcmp (rs
->buf
, "OK") == 0)
7183 remote_notif_ack (nc
, rs
->buf
);
7189 fprintf_unfiltered (gdb_stdlog
,
7190 "notif: process: '%s' no pending reply\n",
7195 /* Called when it is decided that STOP_REPLY holds the info of the
7196 event that is to be returned to the core. This function always
7197 destroys STOP_REPLY. */
7200 process_stop_reply (struct stop_reply
*stop_reply
,
7201 struct target_waitstatus
*status
)
7205 *status
= stop_reply
->ws
;
7206 ptid
= stop_reply
->ptid
;
7208 /* If no thread/process was reported by the stub, assume the current
7210 if (ptid_equal (ptid
, null_ptid
))
7211 ptid
= inferior_ptid
;
7213 if (status
->kind
!= TARGET_WAITKIND_EXITED
7214 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7215 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7217 struct private_thread_info
*remote_thr
;
7219 /* Expedited registers. */
7220 if (stop_reply
->regcache
)
7222 struct regcache
*regcache
7223 = get_thread_arch_regcache (ptid
, target_gdbarch ());
7228 VEC_iterate (cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
7231 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
7235 VEC_free (cached_reg_t
, stop_reply
->regcache
);
7238 remote_notice_new_inferior (ptid
, 0);
7239 remote_thr
= get_private_info_ptid (ptid
);
7240 remote_thr
->core
= stop_reply
->core
;
7241 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7242 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7243 remote_thr
->vcont_resumed
= 0;
7246 stop_reply_xfree (stop_reply
);
7250 /* The non-stop mode version of target_wait. */
7253 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7255 struct remote_state
*rs
= get_remote_state ();
7256 struct stop_reply
*stop_reply
;
7260 /* If in non-stop mode, get out of getpkt even if a
7261 notification is received. */
7263 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7264 0 /* forever */, &is_notif
);
7267 if (ret
!= -1 && !is_notif
)
7270 case 'E': /* Error of some sort. */
7271 /* We're out of sync with the target now. Did it continue
7272 or not? We can't tell which thread it was in non-stop,
7273 so just ignore this. */
7274 warning (_("Remote failure reply: %s"), rs
->buf
);
7276 case 'O': /* Console output. */
7277 remote_console_output (rs
->buf
+ 1);
7280 warning (_("Invalid remote reply: %s"), rs
->buf
);
7284 /* Acknowledge a pending stop reply that may have arrived in the
7286 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7287 remote_notif_get_pending_events (¬if_client_stop
);
7289 /* If indeed we noticed a stop reply, we're done. */
7290 stop_reply
= queued_stop_reply (ptid
);
7291 if (stop_reply
!= NULL
)
7292 return process_stop_reply (stop_reply
, status
);
7294 /* Still no event. If we're just polling for an event, then
7295 return to the event loop. */
7296 if (options
& TARGET_WNOHANG
)
7298 status
->kind
= TARGET_WAITKIND_IGNORE
;
7299 return minus_one_ptid
;
7302 /* Otherwise do a blocking wait. */
7303 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7304 1 /* forever */, &is_notif
);
7308 /* Wait until the remote machine stops, then return, storing status in
7309 STATUS just as `wait' would. */
7312 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7314 struct remote_state
*rs
= get_remote_state ();
7315 ptid_t event_ptid
= null_ptid
;
7317 struct stop_reply
*stop_reply
;
7321 status
->kind
= TARGET_WAITKIND_IGNORE
;
7322 status
->value
.integer
= 0;
7324 stop_reply
= queued_stop_reply (ptid
);
7325 if (stop_reply
!= NULL
)
7326 return process_stop_reply (stop_reply
, status
);
7328 if (rs
->cached_wait_status
)
7329 /* Use the cached wait status, but only once. */
7330 rs
->cached_wait_status
= 0;
7335 int forever
= ((options
& TARGET_WNOHANG
) == 0
7336 && wait_forever_enabled_p
);
7338 if (!rs
->waiting_for_stop_reply
)
7340 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7341 return minus_one_ptid
;
7344 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7345 _never_ wait for ever -> test on target_is_async_p().
7346 However, before we do that we need to ensure that the caller
7347 knows how to take the target into/out of async mode. */
7348 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7349 forever
, &is_notif
);
7351 /* GDB gets a notification. Return to core as this event is
7353 if (ret
!= -1 && is_notif
)
7354 return minus_one_ptid
;
7356 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7357 return minus_one_ptid
;
7362 /* Assume that the target has acknowledged Ctrl-C unless we receive
7363 an 'F' or 'O' packet. */
7364 if (buf
[0] != 'F' && buf
[0] != 'O')
7365 rs
->ctrlc_pending_p
= 0;
7369 case 'E': /* Error of some sort. */
7370 /* We're out of sync with the target now. Did it continue or
7371 not? Not is more likely, so report a stop. */
7372 rs
->waiting_for_stop_reply
= 0;
7374 warning (_("Remote failure reply: %s"), buf
);
7375 status
->kind
= TARGET_WAITKIND_STOPPED
;
7376 status
->value
.sig
= GDB_SIGNAL_0
;
7378 case 'F': /* File-I/O request. */
7379 /* GDB may access the inferior memory while handling the File-I/O
7380 request, but we don't want GDB accessing memory while waiting
7381 for a stop reply. See the comments in putpkt_binary. Set
7382 waiting_for_stop_reply to 0 temporarily. */
7383 rs
->waiting_for_stop_reply
= 0;
7384 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
7385 rs
->ctrlc_pending_p
= 0;
7386 /* GDB handled the File-I/O request, and the target is running
7387 again. Keep waiting for events. */
7388 rs
->waiting_for_stop_reply
= 1;
7390 case 'N': case 'T': case 'S': case 'X': case 'W':
7392 struct stop_reply
*stop_reply
;
7394 /* There is a stop reply to handle. */
7395 rs
->waiting_for_stop_reply
= 0;
7398 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
7401 event_ptid
= process_stop_reply (stop_reply
, status
);
7404 case 'O': /* Console output. */
7405 remote_console_output (buf
+ 1);
7408 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7410 /* Zero length reply means that we tried 'S' or 'C' and the
7411 remote system doesn't support it. */
7412 target_terminal_ours_for_output ();
7414 ("Can't send signals to this remote system. %s not sent.\n",
7415 gdb_signal_to_name (rs
->last_sent_signal
));
7416 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7417 target_terminal_inferior ();
7419 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7423 /* else fallthrough */
7425 warning (_("Invalid remote reply: %s"), buf
);
7429 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7430 return minus_one_ptid
;
7431 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7433 /* Nothing interesting happened. If we're doing a non-blocking
7434 poll, we're done. Otherwise, go back to waiting. */
7435 if (options
& TARGET_WNOHANG
)
7436 return minus_one_ptid
;
7440 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7441 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7443 if (!ptid_equal (event_ptid
, null_ptid
))
7444 record_currthread (rs
, event_ptid
);
7446 event_ptid
= inferior_ptid
;
7449 /* A process exit. Invalidate our notion of current thread. */
7450 record_currthread (rs
, minus_one_ptid
);
7455 /* Wait until the remote machine stops, then return, storing status in
7456 STATUS just as `wait' would. */
7459 remote_wait (struct target_ops
*ops
,
7460 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7464 if (target_is_non_stop_p ())
7465 event_ptid
= remote_wait_ns (ptid
, status
, options
);
7467 event_ptid
= remote_wait_as (ptid
, status
, options
);
7469 if (target_is_async_p ())
7471 /* If there are are events left in the queue tell the event loop
7473 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
7474 mark_async_event_handler (remote_async_inferior_event_token
);
7480 /* Fetch a single register using a 'p' packet. */
7483 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
7485 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7486 struct remote_state
*rs
= get_remote_state ();
7488 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7491 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7494 if (reg
->pnum
== -1)
7499 p
+= hexnumstr (p
, reg
->pnum
);
7502 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7506 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
7510 case PACKET_UNKNOWN
:
7513 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7514 gdbarch_register_name (get_regcache_arch (regcache
),
7519 /* If this register is unfetchable, tell the regcache. */
7522 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7526 /* Otherwise, parse and supply the value. */
7532 error (_("fetch_register_using_p: early buf termination"));
7534 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7537 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
7541 /* Fetch the registers included in the target's 'g' packet. */
7544 send_g_packet (void)
7546 struct remote_state
*rs
= get_remote_state ();
7549 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
7550 remote_send (&rs
->buf
, &rs
->buf_size
);
7552 /* We can get out of synch in various cases. If the first character
7553 in the buffer is not a hex character, assume that has happened
7554 and try to fetch another packet to read. */
7555 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7556 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7557 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7558 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7561 fprintf_unfiltered (gdb_stdlog
,
7562 "Bad register packet; fetching a new packet\n");
7563 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7566 buf_len
= strlen (rs
->buf
);
7568 /* Sanity check the received packet. */
7569 if (buf_len
% 2 != 0)
7570 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
7576 process_g_packet (struct regcache
*regcache
)
7578 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7579 struct remote_state
*rs
= get_remote_state ();
7580 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7585 buf_len
= strlen (rs
->buf
);
7587 /* Further sanity checks, with knowledge of the architecture. */
7588 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7589 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
7591 /* Save the size of the packet sent to us by the target. It is used
7592 as a heuristic when determining the max size of packets that the
7593 target can safely receive. */
7594 if (rsa
->actual_register_packet_size
== 0)
7595 rsa
->actual_register_packet_size
= buf_len
;
7597 /* If this is smaller than we guessed the 'g' packet would be,
7598 update our records. A 'g' reply that doesn't include a register's
7599 value implies either that the register is not available, or that
7600 the 'p' packet must be used. */
7601 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7603 long sizeof_g_packet
= buf_len
/ 2;
7605 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7607 long offset
= rsa
->regs
[i
].offset
;
7608 long reg_size
= register_size (gdbarch
, i
);
7610 if (rsa
->regs
[i
].pnum
== -1)
7613 if (offset
>= sizeof_g_packet
)
7614 rsa
->regs
[i
].in_g_packet
= 0;
7615 else if (offset
+ reg_size
> sizeof_g_packet
)
7616 error (_("Truncated register %d in remote 'g' packet"), i
);
7618 rsa
->regs
[i
].in_g_packet
= 1;
7621 /* Looks valid enough, we can assume this is the correct length
7622 for a 'g' packet. It's important not to adjust
7623 rsa->sizeof_g_packet if we have truncated registers otherwise
7624 this "if" won't be run the next time the method is called
7625 with a packet of the same size and one of the internal errors
7626 below will trigger instead. */
7627 rsa
->sizeof_g_packet
= sizeof_g_packet
;
7630 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
7632 /* Unimplemented registers read as all bits zero. */
7633 memset (regs
, 0, rsa
->sizeof_g_packet
);
7635 /* Reply describes registers byte by byte, each byte encoded as two
7636 hex characters. Suck them all up, then supply them to the
7637 register cacheing/storage mechanism. */
7640 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
7642 if (p
[0] == 0 || p
[1] == 0)
7643 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
7644 internal_error (__FILE__
, __LINE__
,
7645 _("unexpected end of 'g' packet reply"));
7647 if (p
[0] == 'x' && p
[1] == 'x')
7648 regs
[i
] = 0; /* 'x' */
7650 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7654 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7656 struct packet_reg
*r
= &rsa
->regs
[i
];
7657 long reg_size
= register_size (gdbarch
, i
);
7661 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
))
7662 /* This shouldn't happen - we adjusted in_g_packet above. */
7663 internal_error (__FILE__
, __LINE__
,
7664 _("unexpected end of 'g' packet reply"));
7665 else if (rs
->buf
[r
->offset
* 2] == 'x')
7667 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
7668 /* The register isn't available, mark it as such (at
7669 the same time setting the value to zero). */
7670 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
7673 regcache_raw_supply (regcache
, r
->regnum
,
7680 fetch_registers_using_g (struct regcache
*regcache
)
7683 process_g_packet (regcache
);
7686 /* Make the remote selected traceframe match GDB's selected
7690 set_remote_traceframe (void)
7693 struct remote_state
*rs
= get_remote_state ();
7695 if (rs
->remote_traceframe_number
== get_traceframe_number ())
7698 /* Avoid recursion, remote_trace_find calls us again. */
7699 rs
->remote_traceframe_number
= get_traceframe_number ();
7701 newnum
= target_trace_find (tfind_number
,
7702 get_traceframe_number (), 0, 0, NULL
);
7704 /* Should not happen. If it does, all bets are off. */
7705 if (newnum
!= get_traceframe_number ())
7706 warning (_("could not set remote traceframe"));
7710 remote_fetch_registers (struct target_ops
*ops
,
7711 struct regcache
*regcache
, int regnum
)
7713 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7716 set_remote_traceframe ();
7717 set_general_thread (regcache_get_ptid (regcache
));
7721 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7723 gdb_assert (reg
!= NULL
);
7725 /* If this register might be in the 'g' packet, try that first -
7726 we are likely to read more than one register. If this is the
7727 first 'g' packet, we might be overly optimistic about its
7728 contents, so fall back to 'p'. */
7729 if (reg
->in_g_packet
)
7731 fetch_registers_using_g (regcache
);
7732 if (reg
->in_g_packet
)
7736 if (fetch_register_using_p (regcache
, reg
))
7739 /* This register is not available. */
7740 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7745 fetch_registers_using_g (regcache
);
7747 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7748 if (!rsa
->regs
[i
].in_g_packet
)
7749 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
7751 /* This register is not available. */
7752 regcache_raw_supply (regcache
, i
, NULL
);
7756 /* Prepare to store registers. Since we may send them all (using a
7757 'G' request), we have to read out the ones we don't want to change
7761 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
7763 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7766 /* Make sure the entire registers array is valid. */
7767 switch (packet_support (PACKET_P
))
7769 case PACKET_DISABLE
:
7770 case PACKET_SUPPORT_UNKNOWN
:
7771 /* Make sure all the necessary registers are cached. */
7772 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7773 if (rsa
->regs
[i
].in_g_packet
)
7774 regcache_raw_update (regcache
, rsa
->regs
[i
].regnum
);
7781 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
7782 packet was not recognized. */
7785 store_register_using_P (const struct regcache
*regcache
,
7786 struct packet_reg
*reg
)
7788 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7789 struct remote_state
*rs
= get_remote_state ();
7790 /* Try storing a single register. */
7791 char *buf
= rs
->buf
;
7792 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7795 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
7798 if (reg
->pnum
== -1)
7801 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
7802 p
= buf
+ strlen (buf
);
7803 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
7804 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
7806 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7808 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
7813 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
7814 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
7815 case PACKET_UNKNOWN
:
7818 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
7822 /* Store register REGNUM, or all registers if REGNUM == -1, from the
7823 contents of the register cache buffer. FIXME: ignores errors. */
7826 store_registers_using_G (const struct regcache
*regcache
)
7828 struct remote_state
*rs
= get_remote_state ();
7829 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7833 /* Extract all the registers in the regcache copying them into a
7838 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
7839 memset (regs
, 0, rsa
->sizeof_g_packet
);
7840 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7842 struct packet_reg
*r
= &rsa
->regs
[i
];
7845 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
7849 /* Command describes registers byte by byte,
7850 each byte encoded as two hex characters. */
7853 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
7855 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
7857 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7858 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7859 error (_("Could not write registers; remote failure reply '%s'"),
7863 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7864 of the register cache buffer. FIXME: ignores errors. */
7867 remote_store_registers (struct target_ops
*ops
,
7868 struct regcache
*regcache
, int regnum
)
7870 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7873 set_remote_traceframe ();
7874 set_general_thread (regcache_get_ptid (regcache
));
7878 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7880 gdb_assert (reg
!= NULL
);
7882 /* Always prefer to store registers using the 'P' packet if
7883 possible; we often change only a small number of registers.
7884 Sometimes we change a larger number; we'd need help from a
7885 higher layer to know to use 'G'. */
7886 if (store_register_using_P (regcache
, reg
))
7889 /* For now, don't complain if we have no way to write the
7890 register. GDB loses track of unavailable registers too
7891 easily. Some day, this may be an error. We don't have
7892 any way to read the register, either... */
7893 if (!reg
->in_g_packet
)
7896 store_registers_using_G (regcache
);
7900 store_registers_using_G (regcache
);
7902 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7903 if (!rsa
->regs
[i
].in_g_packet
)
7904 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
7905 /* See above for why we do not issue an error here. */
7910 /* Return the number of hex digits in num. */
7913 hexnumlen (ULONGEST num
)
7917 for (i
= 0; num
!= 0; i
++)
7920 return std::max (i
, 1);
7923 /* Set BUF to the minimum number of hex digits representing NUM. */
7926 hexnumstr (char *buf
, ULONGEST num
)
7928 int len
= hexnumlen (num
);
7930 return hexnumnstr (buf
, num
, len
);
7934 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7937 hexnumnstr (char *buf
, ULONGEST num
, int width
)
7943 for (i
= width
- 1; i
>= 0; i
--)
7945 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
7952 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7955 remote_address_masked (CORE_ADDR addr
)
7957 unsigned int address_size
= remote_address_size
;
7959 /* If "remoteaddresssize" was not set, default to target address size. */
7961 address_size
= gdbarch_addr_bit (target_gdbarch ());
7963 if (address_size
> 0
7964 && address_size
< (sizeof (ULONGEST
) * 8))
7966 /* Only create a mask when that mask can safely be constructed
7967 in a ULONGEST variable. */
7970 mask
= (mask
<< address_size
) - 1;
7976 /* Determine whether the remote target supports binary downloading.
7977 This is accomplished by sending a no-op memory write of zero length
7978 to the target at the specified address. It does not suffice to send
7979 the whole packet, since many stubs strip the eighth bit and
7980 subsequently compute a wrong checksum, which causes real havoc with
7983 NOTE: This can still lose if the serial line is not eight-bit
7984 clean. In cases like this, the user should clear "remote
7988 check_binary_download (CORE_ADDR addr
)
7990 struct remote_state
*rs
= get_remote_state ();
7992 switch (packet_support (PACKET_X
))
7994 case PACKET_DISABLE
:
7998 case PACKET_SUPPORT_UNKNOWN
:
8004 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8006 p
+= hexnumstr (p
, (ULONGEST
) 0);
8010 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8011 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8013 if (rs
->buf
[0] == '\0')
8016 fprintf_unfiltered (gdb_stdlog
,
8017 "binary downloading NOT "
8018 "supported by target\n");
8019 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8024 fprintf_unfiltered (gdb_stdlog
,
8025 "binary downloading supported by target\n");
8026 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8033 /* Helper function to resize the payload in order to try to get a good
8034 alignment. We try to write an amount of data such that the next write will
8035 start on an address aligned on REMOTE_ALIGN_WRITES. */
8038 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8040 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8043 /* Write memory data directly to the remote machine.
8044 This does not inform the data cache; the data cache uses this.
8045 HEADER is the starting part of the packet.
8046 MEMADDR is the address in the remote memory space.
8047 MYADDR is the address of the buffer in our space.
8048 LEN_UNITS is the number of addressable units to write.
8049 UNIT_SIZE is the length in bytes of an addressable unit.
8050 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8051 should send data as binary ('X'), or hex-encoded ('M').
8053 The function creates packet of the form
8054 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8056 where encoding of <DATA> is terminated by PACKET_FORMAT.
8058 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8061 Return the transferred status, error or OK (an
8062 'enum target_xfer_status' value). Save the number of addressable units
8063 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8065 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8066 exchange between gdb and the stub could look like (?? in place of the
8072 -> $M1000,3:eeeeffffeeee#??
8076 <- eeeeffffeeeedddd */
8078 static enum target_xfer_status
8079 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8080 const gdb_byte
*myaddr
, ULONGEST len_units
,
8081 int unit_size
, ULONGEST
*xfered_len_units
,
8082 char packet_format
, int use_length
)
8084 struct remote_state
*rs
= get_remote_state ();
8090 int payload_capacity_bytes
;
8091 int payload_length_bytes
;
8093 if (packet_format
!= 'X' && packet_format
!= 'M')
8094 internal_error (__FILE__
, __LINE__
,
8095 _("remote_write_bytes_aux: bad packet format"));
8098 return TARGET_XFER_EOF
;
8100 payload_capacity_bytes
= get_memory_write_packet_size ();
8102 /* The packet buffer will be large enough for the payload;
8103 get_memory_packet_size ensures this. */
8106 /* Compute the size of the actual payload by subtracting out the
8107 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8109 payload_capacity_bytes
-= strlen ("$,:#NN");
8111 /* The comma won't be used. */
8112 payload_capacity_bytes
+= 1;
8113 payload_capacity_bytes
-= strlen (header
);
8114 payload_capacity_bytes
-= hexnumlen (memaddr
);
8116 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8118 strcat (rs
->buf
, header
);
8119 p
= rs
->buf
+ strlen (header
);
8121 /* Compute a best guess of the number of bytes actually transfered. */
8122 if (packet_format
== 'X')
8124 /* Best guess at number of bytes that will fit. */
8125 todo_units
= std::min (len_units
,
8126 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8128 payload_capacity_bytes
-= hexnumlen (todo_units
);
8129 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8133 /* Number of bytes that will fit. */
8135 = std::min (len_units
,
8136 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8138 payload_capacity_bytes
-= hexnumlen (todo_units
);
8139 todo_units
= std::min (todo_units
,
8140 (payload_capacity_bytes
/ unit_size
) / 2);
8143 if (todo_units
<= 0)
8144 internal_error (__FILE__
, __LINE__
,
8145 _("minimum packet size too small to write data"));
8147 /* If we already need another packet, then try to align the end
8148 of this packet to a useful boundary. */
8149 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8150 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8152 /* Append "<memaddr>". */
8153 memaddr
= remote_address_masked (memaddr
);
8154 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8161 /* Append the length and retain its location and size. It may need to be
8162 adjusted once the packet body has been created. */
8164 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8172 /* Append the packet body. */
8173 if (packet_format
== 'X')
8175 /* Binary mode. Send target system values byte by byte, in
8176 increasing byte addresses. Only escape certain critical
8178 payload_length_bytes
=
8179 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8180 &units_written
, payload_capacity_bytes
);
8182 /* If not all TODO units fit, then we'll need another packet. Make
8183 a second try to keep the end of the packet aligned. Don't do
8184 this if the packet is tiny. */
8185 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8189 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8191 if (new_todo_units
!= units_written
)
8192 payload_length_bytes
=
8193 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8194 (gdb_byte
*) p
, &units_written
,
8195 payload_capacity_bytes
);
8198 p
+= payload_length_bytes
;
8199 if (use_length
&& units_written
< todo_units
)
8201 /* Escape chars have filled up the buffer prematurely,
8202 and we have actually sent fewer units than planned.
8203 Fix-up the length field of the packet. Use the same
8204 number of characters as before. */
8205 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8207 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8212 /* Normal mode: Send target system values byte by byte, in
8213 increasing byte addresses. Each byte is encoded as a two hex
8215 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8216 units_written
= todo_units
;
8219 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8220 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8222 if (rs
->buf
[0] == 'E')
8223 return TARGET_XFER_E_IO
;
8225 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8226 send fewer units than we'd planned. */
8227 *xfered_len_units
= (ULONGEST
) units_written
;
8228 return TARGET_XFER_OK
;
8231 /* Write memory data directly to the remote machine.
8232 This does not inform the data cache; the data cache uses this.
8233 MEMADDR is the address in the remote memory space.
8234 MYADDR is the address of the buffer in our space.
8235 LEN is the number of bytes.
8237 Return the transferred status, error or OK (an
8238 'enum target_xfer_status' value). Save the number of bytes
8239 transferred in *XFERED_LEN. Only transfer a single packet. */
8241 static enum target_xfer_status
8242 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
8243 int unit_size
, ULONGEST
*xfered_len
)
8245 const char *packet_format
= NULL
;
8247 /* Check whether the target supports binary download. */
8248 check_binary_download (memaddr
);
8250 switch (packet_support (PACKET_X
))
8253 packet_format
= "X";
8255 case PACKET_DISABLE
:
8256 packet_format
= "M";
8258 case PACKET_SUPPORT_UNKNOWN
:
8259 internal_error (__FILE__
, __LINE__
,
8260 _("remote_write_bytes: bad internal state"));
8262 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8265 return remote_write_bytes_aux (packet_format
,
8266 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8267 packet_format
[0], 1);
8270 /* Read memory data directly from the remote machine.
8271 This does not use the data cache; the data cache uses this.
8272 MEMADDR is the address in the remote memory space.
8273 MYADDR is the address of the buffer in our space.
8274 LEN_UNITS is the number of addressable memory units to read..
8275 UNIT_SIZE is the length in bytes of an addressable unit.
8277 Return the transferred status, error or OK (an
8278 'enum target_xfer_status' value). Save the number of bytes
8279 transferred in *XFERED_LEN_UNITS.
8281 See the comment of remote_write_bytes_aux for an example of
8282 memory read/write exchange between gdb and the stub. */
8284 static enum target_xfer_status
8285 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
8286 int unit_size
, ULONGEST
*xfered_len_units
)
8288 struct remote_state
*rs
= get_remote_state ();
8289 int buf_size_bytes
; /* Max size of packet output buffer. */
8294 buf_size_bytes
= get_memory_read_packet_size ();
8295 /* The packet buffer will be large enough for the payload;
8296 get_memory_packet_size ensures this. */
8298 /* Number of units that will fit. */
8299 todo_units
= std::min (len_units
,
8300 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8302 /* Construct "m"<memaddr>","<len>". */
8303 memaddr
= remote_address_masked (memaddr
);
8306 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8308 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8311 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8312 if (rs
->buf
[0] == 'E'
8313 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8314 && rs
->buf
[3] == '\0')
8315 return TARGET_XFER_E_IO
;
8316 /* Reply describes memory byte by byte, each byte encoded as two hex
8319 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8320 /* Return what we have. Let higher layers handle partial reads. */
8321 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8322 return TARGET_XFER_OK
;
8325 /* Using the set of read-only target sections of remote, read live
8328 For interface/parameters/return description see target.h,
8331 static enum target_xfer_status
8332 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
8333 ULONGEST memaddr
, ULONGEST len
,
8334 int unit_size
, ULONGEST
*xfered_len
)
8336 struct target_section
*secp
;
8337 struct target_section_table
*table
;
8339 secp
= target_section_by_addr (ops
, memaddr
);
8341 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8342 secp
->the_bfd_section
)
8345 struct target_section
*p
;
8346 ULONGEST memend
= memaddr
+ len
;
8348 table
= target_get_section_table (ops
);
8350 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8352 if (memaddr
>= p
->addr
)
8354 if (memend
<= p
->endaddr
)
8356 /* Entire transfer is within this section. */
8357 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8360 else if (memaddr
>= p
->endaddr
)
8362 /* This section ends before the transfer starts. */
8367 /* This section overlaps the transfer. Just do half. */
8368 len
= p
->endaddr
- memaddr
;
8369 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8376 return TARGET_XFER_EOF
;
8379 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8380 first if the requested memory is unavailable in traceframe.
8381 Otherwise, fall back to remote_read_bytes_1. */
8383 static enum target_xfer_status
8384 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
8385 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8386 ULONGEST
*xfered_len
)
8389 return TARGET_XFER_EOF
;
8391 if (get_traceframe_number () != -1)
8393 VEC(mem_range_s
) *available
;
8395 /* If we fail to get the set of available memory, then the
8396 target does not support querying traceframe info, and so we
8397 attempt reading from the traceframe anyway (assuming the
8398 target implements the old QTro packet then). */
8399 if (traceframe_available_memory (&available
, memaddr
, len
))
8401 struct cleanup
*old_chain
;
8403 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
8405 if (VEC_empty (mem_range_s
, available
)
8406 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
8408 enum target_xfer_status res
;
8410 /* Don't read into the traceframe's available
8412 if (!VEC_empty (mem_range_s
, available
))
8414 LONGEST oldlen
= len
;
8416 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
8417 gdb_assert (len
<= oldlen
);
8420 do_cleanups (old_chain
);
8422 /* This goes through the topmost target again. */
8423 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
8424 len
, unit_size
, xfered_len
);
8425 if (res
== TARGET_XFER_OK
)
8426 return TARGET_XFER_OK
;
8429 /* No use trying further, we know some memory starting
8430 at MEMADDR isn't available. */
8432 return TARGET_XFER_UNAVAILABLE
;
8436 /* Don't try to read more than how much is available, in
8437 case the target implements the deprecated QTro packet to
8438 cater for older GDBs (the target's knowledge of read-only
8439 sections may be outdated by now). */
8440 len
= VEC_index (mem_range_s
, available
, 0)->length
;
8442 do_cleanups (old_chain
);
8446 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8451 /* Sends a packet with content determined by the printf format string
8452 FORMAT and the remaining arguments, then gets the reply. Returns
8453 whether the packet was a success, a failure, or unknown. */
8455 static enum packet_result
remote_send_printf (const char *format
, ...)
8456 ATTRIBUTE_PRINTF (1, 2);
8458 static enum packet_result
8459 remote_send_printf (const char *format
, ...)
8461 struct remote_state
*rs
= get_remote_state ();
8462 int max_size
= get_remote_packet_size ();
8465 va_start (ap
, format
);
8468 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
8469 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8471 if (putpkt (rs
->buf
) < 0)
8472 error (_("Communication problem with target."));
8475 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8477 return packet_check_result (rs
->buf
);
8481 restore_remote_timeout (void *p
)
8483 int value
= *(int *)p
;
8485 remote_timeout
= value
;
8488 /* Flash writing can take quite some time. We'll set
8489 effectively infinite timeout for flash operations.
8490 In future, we'll need to decide on a better approach. */
8491 static const int remote_flash_timeout
= 1000;
8494 remote_flash_erase (struct target_ops
*ops
,
8495 ULONGEST address
, LONGEST length
)
8497 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8498 int saved_remote_timeout
= remote_timeout
;
8499 enum packet_result ret
;
8500 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8501 &saved_remote_timeout
);
8503 remote_timeout
= remote_flash_timeout
;
8505 ret
= remote_send_printf ("vFlashErase:%s,%s",
8506 phex (address
, addr_size
),
8510 case PACKET_UNKNOWN
:
8511 error (_("Remote target does not support flash erase"));
8513 error (_("Error erasing flash with vFlashErase packet"));
8518 do_cleanups (back_to
);
8521 static enum target_xfer_status
8522 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
8523 ULONGEST length
, ULONGEST
*xfered_len
,
8524 const gdb_byte
*data
)
8526 int saved_remote_timeout
= remote_timeout
;
8527 enum target_xfer_status ret
;
8528 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8529 &saved_remote_timeout
);
8531 remote_timeout
= remote_flash_timeout
;
8532 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8534 do_cleanups (back_to
);
8540 remote_flash_done (struct target_ops
*ops
)
8542 int saved_remote_timeout
= remote_timeout
;
8544 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8545 &saved_remote_timeout
);
8547 remote_timeout
= remote_flash_timeout
;
8548 ret
= remote_send_printf ("vFlashDone");
8549 do_cleanups (back_to
);
8553 case PACKET_UNKNOWN
:
8554 error (_("Remote target does not support vFlashDone"));
8556 error (_("Error finishing flash operation"));
8563 remote_files_info (struct target_ops
*ignore
)
8565 puts_filtered ("Debugging a target over a serial line.\n");
8568 /* Stuff for dealing with the packets which are part of this protocol.
8569 See comment at top of file for details. */
8571 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8572 error to higher layers. Called when a serial error is detected.
8573 The exception message is STRING, followed by a colon and a blank,
8574 the system error message for errno at function entry and final dot
8575 for output compatibility with throw_perror_with_name. */
8578 unpush_and_perror (const char *string
)
8580 int saved_errno
= errno
;
8582 remote_unpush_target ();
8583 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8584 safe_strerror (saved_errno
));
8587 /* Read a single character from the remote end. The current quit
8588 handler is overridden to avoid quitting in the middle of packet
8589 sequence, as that would break communication with the remote server.
8590 See remote_serial_quit_handler for more detail. */
8593 readchar (int timeout
)
8596 struct remote_state
*rs
= get_remote_state ();
8597 struct cleanup
*old_chain
;
8599 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8601 rs
->got_ctrlc_during_io
= 0;
8603 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8605 if (rs
->got_ctrlc_during_io
)
8608 do_cleanups (old_chain
);
8613 switch ((enum serial_rc
) ch
)
8616 remote_unpush_target ();
8617 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8620 unpush_and_perror (_("Remote communication error. "
8621 "Target disconnected."));
8623 case SERIAL_TIMEOUT
:
8629 /* Wrapper for serial_write that closes the target and throws if
8630 writing fails. The current quit handler is overridden to avoid
8631 quitting in the middle of packet sequence, as that would break
8632 communication with the remote server. See
8633 remote_serial_quit_handler for more detail. */
8636 remote_serial_write (const char *str
, int len
)
8638 struct remote_state
*rs
= get_remote_state ();
8639 struct cleanup
*old_chain
;
8641 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8643 rs
->got_ctrlc_during_io
= 0;
8645 if (serial_write (rs
->remote_desc
, str
, len
))
8647 unpush_and_perror (_("Remote communication error. "
8648 "Target disconnected."));
8651 if (rs
->got_ctrlc_during_io
)
8654 do_cleanups (old_chain
);
8657 /* Send the command in *BUF to the remote machine, and read the reply
8658 into *BUF. Report an error if we get an error reply. Resize
8659 *BUF using xrealloc if necessary to hold the result, and update
8663 remote_send (char **buf
,
8667 getpkt (buf
, sizeof_buf
, 0);
8669 if ((*buf
)[0] == 'E')
8670 error (_("Remote failure reply: %s"), *buf
);
8673 /* Return a string representing an escaped version of BUF, of len N.
8674 E.g. \n is converted to \\n, \t to \\t, etc. */
8677 escape_buffer (const char *buf
, int n
)
8681 stb
.putstrn (buf
, n
, '\\');
8682 return std::move (stb
.string ());
8685 /* Display a null-terminated packet on stdout, for debugging, using C
8689 print_packet (const char *buf
)
8691 puts_filtered ("\"");
8692 fputstr_filtered (buf
, '"', gdb_stdout
);
8693 puts_filtered ("\"");
8697 putpkt (const char *buf
)
8699 return putpkt_binary (buf
, strlen (buf
));
8702 /* Send a packet to the remote machine, with error checking. The data
8703 of the packet is in BUF. The string in BUF can be at most
8704 get_remote_packet_size () - 5 to account for the $, # and checksum,
8705 and for a possible /0 if we are debugging (remote_debug) and want
8706 to print the sent packet as a string. */
8709 putpkt_binary (const char *buf
, int cnt
)
8711 struct remote_state
*rs
= get_remote_state ();
8713 unsigned char csum
= 0;
8714 char *buf2
= (char *) xmalloc (cnt
+ 6);
8715 struct cleanup
*old_chain
= make_cleanup (xfree
, buf2
);
8721 /* Catch cases like trying to read memory or listing threads while
8722 we're waiting for a stop reply. The remote server wouldn't be
8723 ready to handle this request, so we'd hang and timeout. We don't
8724 have to worry about this in synchronous mode, because in that
8725 case it's not possible to issue a command while the target is
8726 running. This is not a problem in non-stop mode, because in that
8727 case, the stub is always ready to process serial input. */
8728 if (!target_is_non_stop_p ()
8729 && target_is_async_p ()
8730 && rs
->waiting_for_stop_reply
)
8732 error (_("Cannot execute this command while the target is running.\n"
8733 "Use the \"interrupt\" command to stop the target\n"
8734 "and then try again."));
8737 /* We're sending out a new packet. Make sure we don't look at a
8738 stale cached response. */
8739 rs
->cached_wait_status
= 0;
8741 /* Copy the packet into buffer BUF2, encapsulating it
8742 and giving it a checksum. */
8747 for (i
= 0; i
< cnt
; i
++)
8753 *p
++ = tohex ((csum
>> 4) & 0xf);
8754 *p
++ = tohex (csum
& 0xf);
8756 /* Send it over and over until we get a positive ack. */
8760 int started_error_output
= 0;
8766 int len
= (int) (p
- buf2
);
8769 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
8771 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
8773 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
8775 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
8776 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
8779 fprintf_unfiltered (gdb_stdlog
, "...");
8781 gdb_flush (gdb_stdlog
);
8783 remote_serial_write (buf2
, p
- buf2
);
8785 /* If this is a no acks version of the remote protocol, send the
8786 packet and move on. */
8790 /* Read until either a timeout occurs (-2) or '+' is read.
8791 Handle any notification that arrives in the mean time. */
8794 ch
= readchar (remote_timeout
);
8802 case SERIAL_TIMEOUT
:
8805 if (started_error_output
)
8807 putchar_unfiltered ('\n');
8808 started_error_output
= 0;
8817 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
8818 do_cleanups (old_chain
);
8822 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
8824 case SERIAL_TIMEOUT
:
8828 do_cleanups (old_chain
);
8831 break; /* Retransmit buffer. */
8835 fprintf_unfiltered (gdb_stdlog
,
8836 "Packet instead of Ack, ignoring it\n");
8837 /* It's probably an old response sent because an ACK
8838 was lost. Gobble up the packet and ack it so it
8839 doesn't get retransmitted when we resend this
8842 remote_serial_write ("+", 1);
8843 continue; /* Now, go look for +. */
8850 /* If we got a notification, handle it, and go back to looking
8852 /* We've found the start of a notification. Now
8853 collect the data. */
8854 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
8859 std::string str
= escape_buffer (rs
->buf
, val
);
8861 fprintf_unfiltered (gdb_stdlog
,
8862 " Notification received: %s\n",
8865 handle_notification (rs
->notif_state
, rs
->buf
);
8866 /* We're in sync now, rewait for the ack. */
8873 if (!started_error_output
)
8875 started_error_output
= 1;
8876 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8878 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8879 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
8888 if (!started_error_output
)
8890 started_error_output
= 1;
8891 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8893 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8897 break; /* Here to retransmit. */
8901 /* This is wrong. If doing a long backtrace, the user should be
8902 able to get out next time we call QUIT, without anything as
8903 violent as interrupt_query. If we want to provide a way out of
8904 here without getting to the next QUIT, it should be based on
8905 hitting ^C twice as in remote_wait. */
8914 do_cleanups (old_chain
);
8918 /* Come here after finding the start of a frame when we expected an
8919 ack. Do our best to discard the rest of this packet. */
8928 c
= readchar (remote_timeout
);
8931 case SERIAL_TIMEOUT
:
8932 /* Nothing we can do. */
8935 /* Discard the two bytes of checksum and stop. */
8936 c
= readchar (remote_timeout
);
8938 c
= readchar (remote_timeout
);
8941 case '*': /* Run length encoding. */
8942 /* Discard the repeat count. */
8943 c
= readchar (remote_timeout
);
8948 /* A regular character. */
8954 /* Come here after finding the start of the frame. Collect the rest
8955 into *BUF, verifying the checksum, length, and handling run-length
8956 compression. NUL terminate the buffer. If there is not enough room,
8957 expand *BUF using xrealloc.
8959 Returns -1 on error, number of characters in buffer (ignoring the
8960 trailing NULL) on success. (could be extended to return one of the
8961 SERIAL status indications). */
8964 read_frame (char **buf_p
,
8971 struct remote_state
*rs
= get_remote_state ();
8978 c
= readchar (remote_timeout
);
8981 case SERIAL_TIMEOUT
:
8983 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
8987 fputs_filtered ("Saw new packet start in middle of old one\n",
8989 return -1; /* Start a new packet, count retries. */
8992 unsigned char pktcsum
;
8998 check_0
= readchar (remote_timeout
);
9000 check_1
= readchar (remote_timeout
);
9002 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9005 fputs_filtered ("Timeout in checksum, retrying\n",
9009 else if (check_0
< 0 || check_1
< 0)
9012 fputs_filtered ("Communication error in checksum\n",
9017 /* Don't recompute the checksum; with no ack packets we
9018 don't have any way to indicate a packet retransmission
9023 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9024 if (csum
== pktcsum
)
9029 std::string str
= escape_buffer (buf
, bc
);
9031 fprintf_unfiltered (gdb_stdlog
,
9032 "Bad checksum, sentsum=0x%x, "
9033 "csum=0x%x, buf=%s\n",
9034 pktcsum
, csum
, str
.c_str ());
9036 /* Number of characters in buffer ignoring trailing
9040 case '*': /* Run length encoding. */
9045 c
= readchar (remote_timeout
);
9047 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9049 /* The character before ``*'' is repeated. */
9051 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9053 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
9055 /* Make some more room in the buffer. */
9056 *sizeof_buf
+= repeat
;
9057 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9061 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9067 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9071 if (bc
>= *sizeof_buf
- 1)
9073 /* Make some more room in the buffer. */
9075 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9086 /* Read a packet from the remote machine, with error checking, and
9087 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9088 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9089 rather than timing out; this is used (in synchronous mode) to wait
9090 for a target that is is executing user code to stop. */
9091 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9092 don't have to change all the calls to getpkt to deal with the
9093 return value, because at the moment I don't know what the right
9094 thing to do it for those. */
9100 getpkt_sane (buf
, sizeof_buf
, forever
);
9104 /* Read a packet from the remote machine, with error checking, and
9105 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9106 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9107 rather than timing out; this is used (in synchronous mode) to wait
9108 for a target that is is executing user code to stop. If FOREVER ==
9109 0, this function is allowed to time out gracefully and return an
9110 indication of this to the caller. Otherwise return the number of
9111 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9112 enough reason to return to the caller. *IS_NOTIF is an output
9113 boolean that indicates whether *BUF holds a notification or not
9114 (a regular packet). */
9117 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
9118 int expecting_notif
, int *is_notif
)
9120 struct remote_state
*rs
= get_remote_state ();
9126 /* We're reading a new response. Make sure we don't look at a
9127 previously cached response. */
9128 rs
->cached_wait_status
= 0;
9130 strcpy (*buf
, "timeout");
9133 timeout
= watchdog
> 0 ? watchdog
: -1;
9134 else if (expecting_notif
)
9135 timeout
= 0; /* There should already be a char in the buffer. If
9138 timeout
= remote_timeout
;
9142 /* Process any number of notifications, and then return when
9146 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9148 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9150 /* This can loop forever if the remote side sends us
9151 characters continuously, but if it pauses, we'll get
9152 SERIAL_TIMEOUT from readchar because of timeout. Then
9153 we'll count that as a retry.
9155 Note that even when forever is set, we will only wait
9156 forever prior to the start of a packet. After that, we
9157 expect characters to arrive at a brisk pace. They should
9158 show up within remote_timeout intervals. */
9160 c
= readchar (timeout
);
9161 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9163 if (c
== SERIAL_TIMEOUT
)
9165 if (expecting_notif
)
9166 return -1; /* Don't complain, it's normal to not get
9167 anything in this case. */
9169 if (forever
) /* Watchdog went off? Kill the target. */
9171 remote_unpush_target ();
9172 throw_error (TARGET_CLOSE_ERROR
,
9173 _("Watchdog timeout has expired. "
9174 "Target detached."));
9177 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9181 /* We've found the start of a packet or notification.
9182 Now collect the data. */
9183 val
= read_frame (buf
, sizeof_buf
);
9188 remote_serial_write ("-", 1);
9191 if (tries
> MAX_TRIES
)
9193 /* We have tried hard enough, and just can't receive the
9194 packet/notification. Give up. */
9195 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9197 /* Skip the ack char if we're in no-ack mode. */
9198 if (!rs
->noack_mode
)
9199 remote_serial_write ("+", 1);
9203 /* If we got an ordinary packet, return that to our caller. */
9209 = escape_buffer (*buf
,
9210 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9212 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9215 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
9217 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
9218 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
9221 fprintf_unfiltered (gdb_stdlog
, "\n");
9224 /* Skip the ack char if we're in no-ack mode. */
9225 if (!rs
->noack_mode
)
9226 remote_serial_write ("+", 1);
9227 if (is_notif
!= NULL
)
9232 /* If we got a notification, handle it, and go back to looking
9236 gdb_assert (c
== '%');
9240 std::string str
= escape_buffer (*buf
, val
);
9242 fprintf_unfiltered (gdb_stdlog
,
9243 " Notification received: %s\n",
9246 if (is_notif
!= NULL
)
9249 handle_notification (rs
->notif_state
, *buf
);
9251 /* Notifications require no acknowledgement. */
9253 if (expecting_notif
)
9260 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
9262 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
9266 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
9269 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
9273 /* Check whether EVENT is a fork event for the process specified
9274 by the pid passed in DATA, and if it is, kill the fork child. */
9277 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
9278 QUEUE_ITER (stop_reply_p
) *iter
,
9282 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
9283 int parent_pid
= *(int *) param
->input
;
9285 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
9287 struct remote_state
*rs
= get_remote_state ();
9288 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
9291 res
= remote_vkill (child_pid
, rs
);
9293 error (_("Can't kill fork child process %d"), child_pid
);
9299 /* Kill any new fork children of process PID that haven't been
9300 processed by follow_fork. */
9303 kill_new_fork_children (int pid
, struct remote_state
*rs
)
9305 struct thread_info
*thread
;
9306 struct notif_client
*notif
= ¬if_client_stop
;
9307 struct queue_iter_param param
;
9309 /* Kill the fork child threads of any threads in process PID
9310 that are stopped at a fork event. */
9311 ALL_NON_EXITED_THREADS (thread
)
9313 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9315 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9317 struct remote_state
*rs
= get_remote_state ();
9318 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
9321 res
= remote_vkill (child_pid
, rs
);
9323 error (_("Can't kill fork child process %d"), child_pid
);
9327 /* Check for any pending fork events (not reported or processed yet)
9328 in process PID and kill those fork child threads as well. */
9329 remote_notif_get_pending_events (notif
);
9331 param
.output
= NULL
;
9332 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
9333 kill_child_of_pending_fork
, ¶m
);
9337 /* Target hook to kill the current inferior. */
9340 remote_kill (struct target_ops
*ops
)
9343 int pid
= ptid_get_pid (inferior_ptid
);
9344 struct remote_state
*rs
= get_remote_state ();
9346 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9348 /* If we're stopped while forking and we haven't followed yet,
9349 kill the child task. We need to do this before killing the
9350 parent task because if this is a vfork then the parent will
9352 kill_new_fork_children (pid
, rs
);
9354 res
= remote_vkill (pid
, rs
);
9357 target_mourn_inferior (inferior_ptid
);
9362 /* If we are in 'target remote' mode and we are killing the only
9363 inferior, then we will tell gdbserver to exit and unpush the
9365 if (res
== -1 && !remote_multi_process_p (rs
)
9366 && number_of_live_inferiors () == 1)
9370 /* We've killed the remote end, we get to mourn it. If we are
9371 not in extended mode, mourning the inferior also unpushes
9372 remote_ops from the target stack, which closes the remote
9374 target_mourn_inferior (inferior_ptid
);
9379 error (_("Can't kill process"));
9382 /* Send a kill request to the target using the 'vKill' packet. */
9385 remote_vkill (int pid
, struct remote_state
*rs
)
9387 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9390 /* Tell the remote target to detach. */
9391 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
9393 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9395 switch (packet_ok (rs
->buf
,
9396 &remote_protocol_packets
[PACKET_vKill
]))
9402 case PACKET_UNKNOWN
:
9405 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9409 /* Send a kill request to the target using the 'k' packet. */
9412 remote_kill_k (void)
9414 /* Catch errors so the user can quit from gdb even when we
9415 aren't on speaking terms with the remote system. */
9420 CATCH (ex
, RETURN_MASK_ERROR
)
9422 if (ex
.error
== TARGET_CLOSE_ERROR
)
9424 /* If we got an (EOF) error that caused the target
9425 to go away, then we're done, that's what we wanted.
9426 "k" is susceptible to cause a premature EOF, given
9427 that the remote server isn't actually required to
9428 reply to "k", and it can happen that it doesn't
9429 even get to reply ACK to the "k". */
9433 /* Otherwise, something went wrong. We didn't actually kill
9434 the target. Just propagate the exception, and let the
9435 user or higher layers decide what to do. */
9436 throw_exception (ex
);
9442 remote_mourn (struct target_ops
*target
)
9444 struct remote_state
*rs
= get_remote_state ();
9446 /* In 'target remote' mode with one inferior, we close the connection. */
9447 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9449 unpush_target (target
);
9451 /* remote_close takes care of doing most of the clean up. */
9452 generic_mourn_inferior ();
9456 /* In case we got here due to an error, but we're going to stay
9458 rs
->waiting_for_stop_reply
= 0;
9460 /* If the current general thread belonged to the process we just
9461 detached from or has exited, the remote side current general
9462 thread becomes undefined. Considering a case like this:
9464 - We just got here due to a detach.
9465 - The process that we're detaching from happens to immediately
9466 report a global breakpoint being hit in non-stop mode, in the
9467 same thread we had selected before.
9468 - GDB attaches to this process again.
9469 - This event happens to be the next event we handle.
9471 GDB would consider that the current general thread didn't need to
9472 be set on the stub side (with Hg), since for all it knew,
9473 GENERAL_THREAD hadn't changed.
9475 Notice that although in all-stop mode, the remote server always
9476 sets the current thread to the thread reporting the stop event,
9477 that doesn't happen in non-stop mode; in non-stop, the stub *must
9478 not* change the current thread when reporting a breakpoint hit,
9479 due to the decoupling of event reporting and event handling.
9481 To keep things simple, we always invalidate our notion of the
9483 record_currthread (rs
, minus_one_ptid
);
9485 /* Call common code to mark the inferior as not running. */
9486 generic_mourn_inferior ();
9488 if (!have_inferiors ())
9490 if (!remote_multi_process_p (rs
))
9492 /* Check whether the target is running now - some remote stubs
9493 automatically restart after kill. */
9495 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9497 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9499 /* Assume that the target has been restarted. Set
9500 inferior_ptid so that bits of core GDB realizes
9501 there's something here, e.g., so that the user can
9502 say "kill" again. */
9503 inferior_ptid
= magic_null_ptid
;
9510 extended_remote_supports_disable_randomization (struct target_ops
*self
)
9512 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9516 extended_remote_disable_randomization (int val
)
9518 struct remote_state
*rs
= get_remote_state ();
9521 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
9524 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9526 error (_("Target does not support QDisableRandomization."));
9527 if (strcmp (reply
, "OK") != 0)
9528 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9532 extended_remote_run (const std::string
&args
)
9534 struct remote_state
*rs
= get_remote_state ();
9536 const char *remote_exec_file
= get_remote_exec_file ();
9538 /* If the user has disabled vRun support, or we have detected that
9539 support is not available, do not try it. */
9540 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9543 strcpy (rs
->buf
, "vRun;");
9544 len
= strlen (rs
->buf
);
9546 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9547 error (_("Remote file name too long for run packet"));
9548 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
9549 strlen (remote_exec_file
));
9553 struct cleanup
*back_to
;
9557 argv
= gdb_buildargv (args
.c_str ());
9558 back_to
= make_cleanup_freeargv (argv
);
9559 for (i
= 0; argv
[i
] != NULL
; i
++)
9561 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9562 error (_("Argument list too long for run packet"));
9563 rs
->buf
[len
++] = ';';
9564 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
9567 do_cleanups (back_to
);
9570 rs
->buf
[len
++] = '\0';
9573 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9575 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9578 /* We have a wait response. All is well. */
9580 case PACKET_UNKNOWN
:
9583 if (remote_exec_file
[0] == '\0')
9584 error (_("Running the default executable on the remote target failed; "
9585 "try \"set remote exec-file\"?"));
9587 error (_("Running \"%s\" on the remote target failed"),
9590 gdb_assert_not_reached (_("bad switch"));
9594 /* In the extended protocol we want to be able to do things like
9595 "run" and have them basically work as expected. So we need
9596 a special create_inferior function. We support changing the
9597 executable file and the command line arguments, but not the
9601 extended_remote_create_inferior (struct target_ops
*ops
,
9602 const char *exec_file
,
9603 const std::string
&args
,
9604 char **env
, int from_tty
)
9608 struct remote_state
*rs
= get_remote_state ();
9609 const char *remote_exec_file
= get_remote_exec_file ();
9611 /* If running asynchronously, register the target file descriptor
9612 with the event loop. */
9613 if (target_can_async_p ())
9616 /* Disable address space randomization if requested (and supported). */
9617 if (extended_remote_supports_disable_randomization (ops
))
9618 extended_remote_disable_randomization (disable_randomization
);
9620 /* If startup-with-shell is on, we inform gdbserver to start the
9621 remote inferior using a shell. */
9622 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
9624 xsnprintf (rs
->buf
, get_remote_packet_size (),
9625 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
9627 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9628 if (strcmp (rs
->buf
, "OK") != 0)
9630 Remote replied unexpectedly while setting startup-with-shell: %s"),
9634 /* Now restart the remote server. */
9635 run_worked
= extended_remote_run (args
) != -1;
9638 /* vRun was not supported. Fail if we need it to do what the
9640 if (remote_exec_file
[0])
9641 error (_("Remote target does not support \"set remote exec-file\""));
9643 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9645 /* Fall back to "R". */
9646 extended_remote_restart ();
9649 if (!have_inferiors ())
9651 /* Clean up from the last time we ran, before we mark the target
9652 running again. This will mark breakpoints uninserted, and
9653 get_offsets may insert breakpoints. */
9654 init_thread_list ();
9655 init_wait_for_inferior ();
9658 /* vRun's success return is a stop reply. */
9659 stop_reply
= run_worked
? rs
->buf
: NULL
;
9660 add_current_inferior_and_thread (stop_reply
);
9662 /* Get updated offsets, if the stub uses qOffsets. */
9667 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9668 the list of conditions (in agent expression bytecode format), if any, the
9669 target needs to evaluate. The output is placed into the packet buffer
9670 started from BUF and ended at BUF_END. */
9673 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
9674 struct bp_target_info
*bp_tgt
, char *buf
,
9677 if (bp_tgt
->conditions
.empty ())
9680 buf
+= strlen (buf
);
9681 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
9684 /* Send conditions to the target. */
9685 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
9687 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
9688 buf
+= strlen (buf
);
9689 for (int i
= 0; i
< aexpr
->len
; ++i
)
9690 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9697 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
9698 struct bp_target_info
*bp_tgt
, char *buf
)
9700 if (bp_tgt
->tcommands
.empty ())
9703 buf
+= strlen (buf
);
9705 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
9706 buf
+= strlen (buf
);
9708 /* Concatenate all the agent expressions that are commands into the
9710 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
9712 sprintf (buf
, "X%x,", aexpr
->len
);
9713 buf
+= strlen (buf
);
9714 for (int i
= 0; i
< aexpr
->len
; ++i
)
9715 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9720 /* Insert a breakpoint. On targets that have software breakpoint
9721 support, we ask the remote target to do the work; on targets
9722 which don't, we insert a traditional memory breakpoint. */
9725 remote_insert_breakpoint (struct target_ops
*ops
,
9726 struct gdbarch
*gdbarch
,
9727 struct bp_target_info
*bp_tgt
)
9729 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9730 If it succeeds, then set the support to PACKET_ENABLE. If it
9731 fails, and the user has explicitly requested the Z support then
9732 report an error, otherwise, mark it disabled and go on. */
9734 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9736 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9737 struct remote_state
*rs
;
9741 /* Make sure the remote is pointing at the right process, if
9743 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9744 set_general_process ();
9746 rs
= get_remote_state ();
9748 endbuf
= rs
->buf
+ get_remote_packet_size ();
9753 addr
= (ULONGEST
) remote_address_masked (addr
);
9754 p
+= hexnumstr (p
, addr
);
9755 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9757 if (remote_supports_cond_breakpoints (ops
))
9758 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
9760 if (remote_can_run_breakpoint_commands (ops
))
9761 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
9764 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9766 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
9772 case PACKET_UNKNOWN
:
9777 /* If this breakpoint has target-side commands but this stub doesn't
9778 support Z0 packets, throw error. */
9779 if (!bp_tgt
->tcommands
.empty ())
9780 throw_error (NOT_SUPPORTED_ERROR
, _("\
9781 Target doesn't support breakpoints that have target side commands."));
9783 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
9787 remote_remove_breakpoint (struct target_ops
*ops
,
9788 struct gdbarch
*gdbarch
,
9789 struct bp_target_info
*bp_tgt
,
9790 enum remove_bp_reason reason
)
9792 CORE_ADDR addr
= bp_tgt
->placed_address
;
9793 struct remote_state
*rs
= get_remote_state ();
9795 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9798 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9800 /* Make sure the remote is pointing at the right process, if
9802 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9803 set_general_process ();
9809 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
9810 p
+= hexnumstr (p
, addr
);
9811 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9814 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9816 return (rs
->buf
[0] == 'E');
9819 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
, reason
);
9822 static enum Z_packet_type
9823 watchpoint_to_Z_packet (int type
)
9828 return Z_PACKET_WRITE_WP
;
9831 return Z_PACKET_READ_WP
;
9834 return Z_PACKET_ACCESS_WP
;
9837 internal_error (__FILE__
, __LINE__
,
9838 _("hw_bp_to_z: bad watchpoint type %d"), type
);
9843 remote_insert_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9844 enum target_hw_bp_type type
, struct expression
*cond
)
9846 struct remote_state
*rs
= get_remote_state ();
9847 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9849 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9851 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9854 /* Make sure the remote is pointing at the right process, if
9856 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9857 set_general_process ();
9859 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
9860 p
= strchr (rs
->buf
, '\0');
9861 addr
= remote_address_masked (addr
);
9862 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9863 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9866 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9868 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9872 case PACKET_UNKNOWN
:
9877 internal_error (__FILE__
, __LINE__
,
9878 _("remote_insert_watchpoint: reached end of function"));
9882 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
9883 CORE_ADDR start
, int length
)
9885 CORE_ADDR diff
= remote_address_masked (addr
- start
);
9887 return diff
< length
;
9892 remote_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9893 enum target_hw_bp_type type
, struct expression
*cond
)
9895 struct remote_state
*rs
= get_remote_state ();
9896 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9898 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9900 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9903 /* Make sure the remote is pointing at the right process, if
9905 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9906 set_general_process ();
9908 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
9909 p
= strchr (rs
->buf
, '\0');
9910 addr
= remote_address_masked (addr
);
9911 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9912 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9914 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9916 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9919 case PACKET_UNKNOWN
:
9924 internal_error (__FILE__
, __LINE__
,
9925 _("remote_remove_watchpoint: reached end of function"));
9929 int remote_hw_watchpoint_limit
= -1;
9930 int remote_hw_watchpoint_length_limit
= -1;
9931 int remote_hw_breakpoint_limit
= -1;
9934 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
9935 CORE_ADDR addr
, int len
)
9937 if (remote_hw_watchpoint_length_limit
== 0)
9939 else if (remote_hw_watchpoint_length_limit
< 0)
9941 else if (len
<= remote_hw_watchpoint_length_limit
)
9948 remote_check_watch_resources (struct target_ops
*self
,
9949 enum bptype type
, int cnt
, int ot
)
9951 if (type
== bp_hardware_breakpoint
)
9953 if (remote_hw_breakpoint_limit
== 0)
9955 else if (remote_hw_breakpoint_limit
< 0)
9957 else if (cnt
<= remote_hw_breakpoint_limit
)
9962 if (remote_hw_watchpoint_limit
== 0)
9964 else if (remote_hw_watchpoint_limit
< 0)
9968 else if (cnt
<= remote_hw_watchpoint_limit
)
9974 /* The to_stopped_by_sw_breakpoint method of target remote. */
9977 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9979 struct thread_info
*thread
= inferior_thread ();
9981 return (thread
->priv
!= NULL
9982 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
9985 /* The to_supports_stopped_by_sw_breakpoint method of target
9989 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9991 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
9994 /* The to_stopped_by_hw_breakpoint method of target remote. */
9997 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
9999 struct thread_info
*thread
= inferior_thread ();
10001 return (thread
->priv
!= NULL
10002 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
10005 /* The to_supports_stopped_by_hw_breakpoint method of target
10009 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10011 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10015 remote_stopped_by_watchpoint (struct target_ops
*ops
)
10017 struct thread_info
*thread
= inferior_thread ();
10019 return (thread
->priv
!= NULL
10020 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
);
10024 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
10026 struct thread_info
*thread
= inferior_thread ();
10028 if (thread
->priv
!= NULL
10029 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
10031 *addr_p
= thread
->priv
->watch_data_address
;
10040 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10041 struct bp_target_info
*bp_tgt
)
10043 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10044 struct remote_state
*rs
;
10048 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10051 /* Make sure the remote is pointing at the right process, if
10053 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10054 set_general_process ();
10056 rs
= get_remote_state ();
10058 endbuf
= rs
->buf
+ get_remote_packet_size ();
10064 addr
= remote_address_masked (addr
);
10065 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10066 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10068 if (remote_supports_cond_breakpoints (self
))
10069 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10071 if (remote_can_run_breakpoint_commands (self
))
10072 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10075 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10077 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10080 if (rs
->buf
[1] == '.')
10082 message
= strchr (rs
->buf
+ 2, '.');
10084 error (_("Remote failure reply: %s"), message
+ 1);
10087 case PACKET_UNKNOWN
:
10092 internal_error (__FILE__
, __LINE__
,
10093 _("remote_insert_hw_breakpoint: reached end of function"));
10098 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10099 struct bp_target_info
*bp_tgt
)
10102 struct remote_state
*rs
= get_remote_state ();
10104 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
10106 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10109 /* Make sure the remote is pointing at the right process, if
10111 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10112 set_general_process ();
10118 addr
= remote_address_masked (bp_tgt
->placed_address
);
10119 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10120 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10123 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10125 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10128 case PACKET_UNKNOWN
:
10133 internal_error (__FILE__
, __LINE__
,
10134 _("remote_remove_hw_breakpoint: reached end of function"));
10137 /* Verify memory using the "qCRC:" request. */
10140 remote_verify_memory (struct target_ops
*ops
,
10141 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10143 struct remote_state
*rs
= get_remote_state ();
10144 unsigned long host_crc
, target_crc
;
10147 /* It doesn't make sense to use qCRC if the remote target is
10148 connected but not running. */
10149 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10151 enum packet_result result
;
10153 /* Make sure the remote is pointing at the right process. */
10154 set_general_process ();
10156 /* FIXME: assumes lma can fit into long. */
10157 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
10158 (long) lma
, (long) size
);
10161 /* Be clever; compute the host_crc before waiting for target
10163 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10165 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10167 result
= packet_ok (rs
->buf
,
10168 &remote_protocol_packets
[PACKET_qCRC
]);
10169 if (result
== PACKET_ERROR
)
10171 else if (result
== PACKET_OK
)
10173 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10174 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10176 return (host_crc
== target_crc
);
10180 return simple_verify_memory (ops
, data
, lma
, size
);
10183 /* compare-sections command
10185 With no arguments, compares each loadable section in the exec bfd
10186 with the same memory range on the target, and reports mismatches.
10187 Useful for verifying the image on the target against the exec file. */
10190 compare_sections_command (char *args
, int from_tty
)
10193 struct cleanup
*old_chain
;
10194 gdb_byte
*sectdata
;
10195 const char *sectname
;
10196 bfd_size_type size
;
10199 int mismatched
= 0;
10204 error (_("command cannot be used without an exec file"));
10206 /* Make sure the remote is pointing at the right process. */
10207 set_general_process ();
10209 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10215 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10217 if (!(s
->flags
& SEC_LOAD
))
10218 continue; /* Skip non-loadable section. */
10220 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10221 continue; /* Skip writeable sections */
10223 size
= bfd_get_section_size (s
);
10225 continue; /* Skip zero-length section. */
10227 sectname
= bfd_get_section_name (exec_bfd
, s
);
10228 if (args
&& strcmp (args
, sectname
) != 0)
10229 continue; /* Not the section selected by user. */
10231 matched
= 1; /* Do this section. */
10234 sectdata
= (gdb_byte
*) xmalloc (size
);
10235 old_chain
= make_cleanup (xfree
, sectdata
);
10236 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
10238 res
= target_verify_memory (sectdata
, lma
, size
);
10241 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10242 paddress (target_gdbarch (), lma
),
10243 paddress (target_gdbarch (), lma
+ size
));
10245 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10246 paddress (target_gdbarch (), lma
),
10247 paddress (target_gdbarch (), lma
+ size
));
10249 printf_filtered ("matched.\n");
10252 printf_filtered ("MIS-MATCHED!\n");
10256 do_cleanups (old_chain
);
10258 if (mismatched
> 0)
10259 warning (_("One or more sections of the target image does not match\n\
10260 the loaded file\n"));
10261 if (args
&& !matched
)
10262 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10265 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10266 into remote target. The number of bytes written to the remote
10267 target is returned, or -1 for error. */
10269 static enum target_xfer_status
10270 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
10271 const char *annex
, const gdb_byte
*writebuf
,
10272 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
10273 struct packet_config
*packet
)
10277 struct remote_state
*rs
= get_remote_state ();
10278 int max_size
= get_memory_write_packet_size ();
10280 if (packet
->support
== PACKET_DISABLE
)
10281 return TARGET_XFER_E_IO
;
10283 /* Insert header. */
10284 i
= snprintf (rs
->buf
, max_size
,
10285 "qXfer:%s:write:%s:%s:",
10286 object_name
, annex
? annex
: "",
10287 phex_nz (offset
, sizeof offset
));
10288 max_size
-= (i
+ 1);
10290 /* Escape as much data as fits into rs->buf. */
10291 buf_len
= remote_escape_output
10292 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
10294 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
10295 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10296 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10297 return TARGET_XFER_E_IO
;
10299 unpack_varlen_hex (rs
->buf
, &n
);
10302 return TARGET_XFER_OK
;
10305 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10306 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10307 number of bytes read is returned, or 0 for EOF, or -1 for error.
10308 The number of bytes read may be less than LEN without indicating an
10309 EOF. PACKET is checked and updated to indicate whether the remote
10310 target supports this object. */
10312 static enum target_xfer_status
10313 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
10315 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
10316 ULONGEST
*xfered_len
,
10317 struct packet_config
*packet
)
10319 struct remote_state
*rs
= get_remote_state ();
10320 LONGEST i
, n
, packet_len
;
10322 if (packet
->support
== PACKET_DISABLE
)
10323 return TARGET_XFER_E_IO
;
10325 /* Check whether we've cached an end-of-object packet that matches
10327 if (rs
->finished_object
)
10329 if (strcmp (object_name
, rs
->finished_object
) == 0
10330 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10331 && offset
== rs
->finished_offset
)
10332 return TARGET_XFER_EOF
;
10335 /* Otherwise, we're now reading something different. Discard
10337 xfree (rs
->finished_object
);
10338 xfree (rs
->finished_annex
);
10339 rs
->finished_object
= NULL
;
10340 rs
->finished_annex
= NULL
;
10343 /* Request only enough to fit in a single packet. The actual data
10344 may not, since we don't know how much of it will need to be escaped;
10345 the target is free to respond with slightly less data. We subtract
10346 five to account for the response type and the protocol frame. */
10347 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10348 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10349 object_name
, annex
? annex
: "",
10350 phex_nz (offset
, sizeof offset
),
10351 phex_nz (n
, sizeof n
));
10352 i
= putpkt (rs
->buf
);
10354 return TARGET_XFER_E_IO
;
10357 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10358 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10359 return TARGET_XFER_E_IO
;
10361 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10362 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
10364 /* 'm' means there is (or at least might be) more data after this
10365 batch. That does not make sense unless there's at least one byte
10366 of data in this reply. */
10367 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10368 error (_("Remote qXfer reply contained no data."));
10370 /* Got some data. */
10371 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
10372 packet_len
- 1, readbuf
, n
);
10374 /* 'l' is an EOF marker, possibly including a final block of data,
10375 or possibly empty. If we have the final block of a non-empty
10376 object, record this fact to bypass a subsequent partial read. */
10377 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10379 rs
->finished_object
= xstrdup (object_name
);
10380 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10381 rs
->finished_offset
= offset
+ i
;
10385 return TARGET_XFER_EOF
;
10389 return TARGET_XFER_OK
;
10393 static enum target_xfer_status
10394 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
10395 const char *annex
, gdb_byte
*readbuf
,
10396 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10397 ULONGEST
*xfered_len
)
10399 struct remote_state
*rs
;
10403 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10405 set_remote_traceframe ();
10406 set_general_thread (inferior_ptid
);
10408 rs
= get_remote_state ();
10410 /* Handle memory using the standard memory routines. */
10411 if (object
== TARGET_OBJECT_MEMORY
)
10413 /* If the remote target is connected but not running, we should
10414 pass this request down to a lower stratum (e.g. the executable
10416 if (!target_has_execution
)
10417 return TARGET_XFER_EOF
;
10419 if (writebuf
!= NULL
)
10420 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10423 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
10427 /* Handle SPU memory using qxfer packets. */
10428 if (object
== TARGET_OBJECT_SPU
)
10431 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
10432 xfered_len
, &remote_protocol_packets
10433 [PACKET_qXfer_spu_read
]);
10435 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
10436 xfered_len
, &remote_protocol_packets
10437 [PACKET_qXfer_spu_write
]);
10440 /* Handle extra signal info using qxfer packets. */
10441 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10444 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
10445 xfered_len
, &remote_protocol_packets
10446 [PACKET_qXfer_siginfo_read
]);
10448 return remote_write_qxfer (ops
, "siginfo", annex
,
10449 writebuf
, offset
, len
, xfered_len
,
10450 &remote_protocol_packets
10451 [PACKET_qXfer_siginfo_write
]);
10454 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10457 return remote_read_qxfer (ops
, "statictrace", annex
,
10458 readbuf
, offset
, len
, xfered_len
,
10459 &remote_protocol_packets
10460 [PACKET_qXfer_statictrace_read
]);
10462 return TARGET_XFER_E_IO
;
10465 /* Only handle flash writes. */
10466 if (writebuf
!= NULL
)
10470 case TARGET_OBJECT_FLASH
:
10471 return remote_flash_write (ops
, offset
, len
, xfered_len
,
10475 return TARGET_XFER_E_IO
;
10479 /* Map pre-existing objects onto letters. DO NOT do this for new
10480 objects!!! Instead specify new query packets. */
10483 case TARGET_OBJECT_AVR
:
10487 case TARGET_OBJECT_AUXV
:
10488 gdb_assert (annex
== NULL
);
10489 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
10491 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10493 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10494 return remote_read_qxfer
10495 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
10496 &remote_protocol_packets
[PACKET_qXfer_features
]);
10498 case TARGET_OBJECT_LIBRARIES
:
10499 return remote_read_qxfer
10500 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10501 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10503 case TARGET_OBJECT_LIBRARIES_SVR4
:
10504 return remote_read_qxfer
10505 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10506 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10508 case TARGET_OBJECT_MEMORY_MAP
:
10509 gdb_assert (annex
== NULL
);
10510 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
10512 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10514 case TARGET_OBJECT_OSDATA
:
10515 /* Should only get here if we're connected. */
10516 gdb_assert (rs
->remote_desc
);
10517 return remote_read_qxfer
10518 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10519 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10521 case TARGET_OBJECT_THREADS
:
10522 gdb_assert (annex
== NULL
);
10523 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
10525 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10527 case TARGET_OBJECT_TRACEFRAME_INFO
:
10528 gdb_assert (annex
== NULL
);
10529 return remote_read_qxfer
10530 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10531 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10533 case TARGET_OBJECT_FDPIC
:
10534 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
10536 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10538 case TARGET_OBJECT_OPENVMS_UIB
:
10539 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
10541 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10543 case TARGET_OBJECT_BTRACE
:
10544 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
10546 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10548 case TARGET_OBJECT_BTRACE_CONF
:
10549 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
10551 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10553 case TARGET_OBJECT_EXEC_FILE
:
10554 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
10556 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10559 return TARGET_XFER_E_IO
;
10562 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10563 large enough let the caller deal with it. */
10564 if (len
< get_remote_packet_size ())
10565 return TARGET_XFER_E_IO
;
10566 len
= get_remote_packet_size ();
10568 /* Except for querying the minimum buffer size, target must be open. */
10569 if (!rs
->remote_desc
)
10570 error (_("remote query is only available after target open"));
10572 gdb_assert (annex
!= NULL
);
10573 gdb_assert (readbuf
!= NULL
);
10577 *p2
++ = query_type
;
10579 /* We used one buffer char for the remote protocol q command and
10580 another for the query type. As the remote protocol encapsulation
10581 uses 4 chars plus one extra in case we are debugging
10582 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10585 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10587 /* Bad caller may have sent forbidden characters. */
10588 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10593 gdb_assert (annex
[i
] == '\0');
10595 i
= putpkt (rs
->buf
);
10597 return TARGET_XFER_E_IO
;
10599 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10600 strcpy ((char *) readbuf
, rs
->buf
);
10602 *xfered_len
= strlen ((char *) readbuf
);
10603 return TARGET_XFER_OK
;
10606 /* Implementation of to_get_memory_xfer_limit. */
10609 remote_get_memory_xfer_limit (struct target_ops
*ops
)
10611 return get_memory_write_packet_size ();
10615 remote_search_memory (struct target_ops
* ops
,
10616 CORE_ADDR start_addr
, ULONGEST search_space_len
,
10617 const gdb_byte
*pattern
, ULONGEST pattern_len
,
10618 CORE_ADDR
*found_addrp
)
10620 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
10621 struct remote_state
*rs
= get_remote_state ();
10622 int max_size
= get_memory_write_packet_size ();
10623 struct packet_config
*packet
=
10624 &remote_protocol_packets
[PACKET_qSearch_memory
];
10625 /* Number of packet bytes used to encode the pattern;
10626 this could be more than PATTERN_LEN due to escape characters. */
10627 int escaped_pattern_len
;
10628 /* Amount of pattern that was encodable in the packet. */
10629 int used_pattern_len
;
10632 ULONGEST found_addr
;
10634 /* Don't go to the target if we don't have to.
10635 This is done before checking packet->support to avoid the possibility that
10636 a success for this edge case means the facility works in general. */
10637 if (pattern_len
> search_space_len
)
10639 if (pattern_len
== 0)
10641 *found_addrp
= start_addr
;
10645 /* If we already know the packet isn't supported, fall back to the simple
10646 way of searching memory. */
10648 if (packet_config_support (packet
) == PACKET_DISABLE
)
10650 /* Target doesn't provided special support, fall back and use the
10651 standard support (copy memory and do the search here). */
10652 return simple_search_memory (ops
, start_addr
, search_space_len
,
10653 pattern
, pattern_len
, found_addrp
);
10656 /* Make sure the remote is pointing at the right process. */
10657 set_general_process ();
10659 /* Insert header. */
10660 i
= snprintf (rs
->buf
, max_size
,
10661 "qSearch:memory:%s;%s;",
10662 phex_nz (start_addr
, addr_size
),
10663 phex_nz (search_space_len
, sizeof (search_space_len
)));
10664 max_size
-= (i
+ 1);
10666 /* Escape as much data as fits into rs->buf. */
10667 escaped_pattern_len
=
10668 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
10669 &used_pattern_len
, max_size
);
10671 /* Bail if the pattern is too large. */
10672 if (used_pattern_len
!= pattern_len
)
10673 error (_("Pattern is too large to transmit to remote target."));
10675 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
10676 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10677 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10679 /* The request may not have worked because the command is not
10680 supported. If so, fall back to the simple way. */
10681 if (packet
->support
== PACKET_DISABLE
)
10683 return simple_search_memory (ops
, start_addr
, search_space_len
,
10684 pattern
, pattern_len
, found_addrp
);
10689 if (rs
->buf
[0] == '0')
10691 else if (rs
->buf
[0] == '1')
10694 if (rs
->buf
[1] != ',')
10695 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10696 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
10697 *found_addrp
= found_addr
;
10700 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10706 remote_rcmd (struct target_ops
*self
, const char *command
,
10707 struct ui_file
*outbuf
)
10709 struct remote_state
*rs
= get_remote_state ();
10712 if (!rs
->remote_desc
)
10713 error (_("remote rcmd is only available after target open"));
10715 /* Send a NULL command across as an empty command. */
10716 if (command
== NULL
)
10719 /* The query prefix. */
10720 strcpy (rs
->buf
, "qRcmd,");
10721 p
= strchr (rs
->buf
, '\0');
10723 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
10724 > get_remote_packet_size ())
10725 error (_("\"monitor\" command ``%s'' is too long."), command
);
10727 /* Encode the actual command. */
10728 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
10730 if (putpkt (rs
->buf
) < 0)
10731 error (_("Communication problem with target."));
10733 /* get/display the response */
10738 /* XXX - see also remote_get_noisy_reply(). */
10739 QUIT
; /* Allow user to bail out with ^C. */
10741 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
10743 /* Timeout. Continue to (try to) read responses.
10744 This is better than stopping with an error, assuming the stub
10745 is still executing the (long) monitor command.
10746 If needed, the user can interrupt gdb using C-c, obtaining
10747 an effect similar to stop on timeout. */
10751 if (buf
[0] == '\0')
10752 error (_("Target does not support this command."));
10753 if (buf
[0] == 'O' && buf
[1] != 'K')
10755 remote_console_output (buf
+ 1); /* 'O' message from stub. */
10758 if (strcmp (buf
, "OK") == 0)
10760 if (strlen (buf
) == 3 && buf
[0] == 'E'
10761 && isdigit (buf
[1]) && isdigit (buf
[2]))
10763 error (_("Protocol error with Rcmd"));
10765 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
10767 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
10769 fputc_unfiltered (c
, outbuf
);
10775 static VEC(mem_region_s
) *
10776 remote_memory_map (struct target_ops
*ops
)
10778 VEC(mem_region_s
) *result
= NULL
;
10779 char *text
= target_read_stralloc (¤t_target
,
10780 TARGET_OBJECT_MEMORY_MAP
, NULL
);
10784 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
10786 result
= parse_memory_map (text
);
10787 do_cleanups (back_to
);
10794 packet_command (char *args
, int from_tty
)
10796 struct remote_state
*rs
= get_remote_state ();
10798 if (!rs
->remote_desc
)
10799 error (_("command can only be used with remote target"));
10802 error (_("remote-packet command requires packet text as argument"));
10804 puts_filtered ("sending: ");
10805 print_packet (args
);
10806 puts_filtered ("\n");
10809 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10810 puts_filtered ("received: ");
10811 print_packet (rs
->buf
);
10812 puts_filtered ("\n");
10816 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10818 static void display_thread_info (struct gdb_ext_thread_info
*info
);
10820 static void threadset_test_cmd (char *cmd
, int tty
);
10822 static void threadalive_test (char *cmd
, int tty
);
10824 static void threadlist_test_cmd (char *cmd
, int tty
);
10826 int get_and_display_threadinfo (threadref
*ref
);
10828 static void threadinfo_test_cmd (char *cmd
, int tty
);
10830 static int thread_display_step (threadref
*ref
, void *context
);
10832 static void threadlist_update_test_cmd (char *cmd
, int tty
);
10834 static void init_remote_threadtests (void);
10836 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10839 threadset_test_cmd (char *cmd
, int tty
)
10841 int sample_thread
= SAMPLE_THREAD
;
10843 printf_filtered (_("Remote threadset test\n"));
10844 set_general_thread (sample_thread
);
10849 threadalive_test (char *cmd
, int tty
)
10851 int sample_thread
= SAMPLE_THREAD
;
10852 int pid
= ptid_get_pid (inferior_ptid
);
10853 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
10855 if (remote_thread_alive (ptid
))
10856 printf_filtered ("PASS: Thread alive test\n");
10858 printf_filtered ("FAIL: Thread alive test\n");
10861 void output_threadid (char *title
, threadref
*ref
);
10864 output_threadid (char *title
, threadref
*ref
)
10868 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
10870 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
10874 threadlist_test_cmd (char *cmd
, int tty
)
10877 threadref nextthread
;
10878 int done
, result_count
;
10879 threadref threadlist
[3];
10881 printf_filtered ("Remote Threadlist test\n");
10882 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
10883 &result_count
, &threadlist
[0]))
10884 printf_filtered ("FAIL: threadlist test\n");
10887 threadref
*scan
= threadlist
;
10888 threadref
*limit
= scan
+ result_count
;
10890 while (scan
< limit
)
10891 output_threadid (" thread ", scan
++);
10896 display_thread_info (struct gdb_ext_thread_info
*info
)
10898 output_threadid ("Threadid: ", &info
->threadid
);
10899 printf_filtered ("Name: %s\n ", info
->shortname
);
10900 printf_filtered ("State: %s\n", info
->display
);
10901 printf_filtered ("other: %s\n\n", info
->more_display
);
10905 get_and_display_threadinfo (threadref
*ref
)
10909 struct gdb_ext_thread_info threadinfo
;
10911 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
10912 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
10913 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
10914 display_thread_info (&threadinfo
);
10919 threadinfo_test_cmd (char *cmd
, int tty
)
10921 int athread
= SAMPLE_THREAD
;
10925 int_to_threadref (&thread
, athread
);
10926 printf_filtered ("Remote Threadinfo test\n");
10927 if (!get_and_display_threadinfo (&thread
))
10928 printf_filtered ("FAIL cannot get thread info\n");
10932 thread_display_step (threadref
*ref
, void *context
)
10934 /* output_threadid(" threadstep ",ref); *//* simple test */
10935 return get_and_display_threadinfo (ref
);
10939 threadlist_update_test_cmd (char *cmd
, int tty
)
10941 printf_filtered ("Remote Threadlist update test\n");
10942 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
10946 init_remote_threadtests (void)
10948 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
10949 _("Fetch and print the remote list of "
10950 "thread identifiers, one pkt only"));
10951 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
10952 _("Fetch and display info about one thread"));
10953 add_com ("tset", class_obscure
, threadset_test_cmd
,
10954 _("Test setting to a different thread"));
10955 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
10956 _("Iterate through updating all remote thread info"));
10957 add_com ("talive", class_obscure
, threadalive_test
,
10958 _(" Remote thread alive test "));
10963 /* Convert a thread ID to a string. Returns the string in a static
10966 static const char *
10967 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
10969 static char buf
[64];
10970 struct remote_state
*rs
= get_remote_state ();
10972 if (ptid_equal (ptid
, null_ptid
))
10973 return normal_pid_to_str (ptid
);
10974 else if (ptid_is_pid (ptid
))
10976 /* Printing an inferior target id. */
10978 /* When multi-process extensions are off, there's no way in the
10979 remote protocol to know the remote process id, if there's any
10980 at all. There's one exception --- when we're connected with
10981 target extended-remote, and we manually attached to a process
10982 with "attach PID". We don't record anywhere a flag that
10983 allows us to distinguish that case from the case of
10984 connecting with extended-remote and the stub already being
10985 attached to a process, and reporting yes to qAttached, hence
10986 no smart special casing here. */
10987 if (!remote_multi_process_p (rs
))
10989 xsnprintf (buf
, sizeof buf
, "Remote target");
10993 return normal_pid_to_str (ptid
);
10997 if (ptid_equal (magic_null_ptid
, ptid
))
10998 xsnprintf (buf
, sizeof buf
, "Thread <main>");
10999 else if (remote_multi_process_p (rs
))
11000 if (ptid_get_lwp (ptid
) == 0)
11001 return normal_pid_to_str (ptid
);
11003 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
11004 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
11006 xsnprintf (buf
, sizeof buf
, "Thread %ld",
11007 ptid_get_lwp (ptid
));
11012 /* Get the address of the thread local variable in OBJFILE which is
11013 stored at OFFSET within the thread local storage for thread PTID. */
11016 remote_get_thread_local_address (struct target_ops
*ops
,
11017 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
11019 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11021 struct remote_state
*rs
= get_remote_state ();
11023 char *endp
= rs
->buf
+ get_remote_packet_size ();
11024 enum packet_result result
;
11026 strcpy (p
, "qGetTLSAddr:");
11028 p
= write_ptid (p
, endp
, ptid
);
11030 p
+= hexnumstr (p
, offset
);
11032 p
+= hexnumstr (p
, lm
);
11036 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11037 result
= packet_ok (rs
->buf
,
11038 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11039 if (result
== PACKET_OK
)
11043 unpack_varlen_hex (rs
->buf
, &result
);
11046 else if (result
== PACKET_UNKNOWN
)
11047 throw_error (TLS_GENERIC_ERROR
,
11048 _("Remote target doesn't support qGetTLSAddr packet"));
11050 throw_error (TLS_GENERIC_ERROR
,
11051 _("Remote target failed to process qGetTLSAddr request"));
11054 throw_error (TLS_GENERIC_ERROR
,
11055 _("TLS not supported or disabled on this target"));
11060 /* Provide thread local base, i.e. Thread Information Block address.
11061 Returns 1 if ptid is found and thread_local_base is non zero. */
11064 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
11066 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11068 struct remote_state
*rs
= get_remote_state ();
11070 char *endp
= rs
->buf
+ get_remote_packet_size ();
11071 enum packet_result result
;
11073 strcpy (p
, "qGetTIBAddr:");
11075 p
= write_ptid (p
, endp
, ptid
);
11079 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11080 result
= packet_ok (rs
->buf
,
11081 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11082 if (result
== PACKET_OK
)
11086 unpack_varlen_hex (rs
->buf
, &result
);
11088 *addr
= (CORE_ADDR
) result
;
11091 else if (result
== PACKET_UNKNOWN
)
11092 error (_("Remote target doesn't support qGetTIBAddr packet"));
11094 error (_("Remote target failed to process qGetTIBAddr request"));
11097 error (_("qGetTIBAddr not supported or disabled on this target"));
11102 /* Support for inferring a target description based on the current
11103 architecture and the size of a 'g' packet. While the 'g' packet
11104 can have any size (since optional registers can be left off the
11105 end), some sizes are easily recognizable given knowledge of the
11106 approximate architecture. */
11108 struct remote_g_packet_guess
11111 const struct target_desc
*tdesc
;
11113 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
11114 DEF_VEC_O(remote_g_packet_guess_s
);
11116 struct remote_g_packet_data
11118 VEC(remote_g_packet_guess_s
) *guesses
;
11121 static struct gdbarch_data
*remote_g_packet_data_handle
;
11124 remote_g_packet_data_init (struct obstack
*obstack
)
11126 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
11130 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11131 const struct target_desc
*tdesc
)
11133 struct remote_g_packet_data
*data
11134 = ((struct remote_g_packet_data
*)
11135 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11136 struct remote_g_packet_guess new_guess
, *guess
;
11139 gdb_assert (tdesc
!= NULL
);
11142 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11144 if (guess
->bytes
== bytes
)
11145 internal_error (__FILE__
, __LINE__
,
11146 _("Duplicate g packet description added for size %d"),
11149 new_guess
.bytes
= bytes
;
11150 new_guess
.tdesc
= tdesc
;
11151 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
11154 /* Return 1 if remote_read_description would do anything on this target
11155 and architecture, 0 otherwise. */
11158 remote_read_description_p (struct target_ops
*target
)
11160 struct remote_g_packet_data
*data
11161 = ((struct remote_g_packet_data
*)
11162 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11164 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11170 static const struct target_desc
*
11171 remote_read_description (struct target_ops
*target
)
11173 struct remote_g_packet_data
*data
11174 = ((struct remote_g_packet_data
*)
11175 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11177 /* Do not try this during initial connection, when we do not know
11178 whether there is a running but stopped thread. */
11179 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
11180 return target
->beneath
->to_read_description (target
->beneath
);
11182 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11184 struct remote_g_packet_guess
*guess
;
11186 int bytes
= send_g_packet ();
11189 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11191 if (guess
->bytes
== bytes
)
11192 return guess
->tdesc
;
11194 /* We discard the g packet. A minor optimization would be to
11195 hold on to it, and fill the register cache once we have selected
11196 an architecture, but it's too tricky to do safely. */
11199 return target
->beneath
->to_read_description (target
->beneath
);
11202 /* Remote file transfer support. This is host-initiated I/O, not
11203 target-initiated; for target-initiated, see remote-fileio.c. */
11205 /* If *LEFT is at least the length of STRING, copy STRING to
11206 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11207 decrease *LEFT. Otherwise raise an error. */
11210 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11212 int len
= strlen (string
);
11215 error (_("Packet too long for target."));
11217 memcpy (*buffer
, string
, len
);
11221 /* NUL-terminate the buffer as a convenience, if there is
11227 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11228 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11229 decrease *LEFT. Otherwise raise an error. */
11232 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11235 if (2 * len
> *left
)
11236 error (_("Packet too long for target."));
11238 bin2hex (bytes
, *buffer
, len
);
11239 *buffer
+= 2 * len
;
11242 /* NUL-terminate the buffer as a convenience, if there is
11248 /* If *LEFT is large enough, convert VALUE to hex and add it to
11249 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11250 decrease *LEFT. Otherwise raise an error. */
11253 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11255 int len
= hexnumlen (value
);
11258 error (_("Packet too long for target."));
11260 hexnumstr (*buffer
, value
);
11264 /* NUL-terminate the buffer as a convenience, if there is
11270 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11271 value, *REMOTE_ERRNO to the remote error number or zero if none
11272 was included, and *ATTACHMENT to point to the start of the annex
11273 if any. The length of the packet isn't needed here; there may
11274 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11276 Return 0 if the packet could be parsed, -1 if it could not. If
11277 -1 is returned, the other variables may not be initialized. */
11280 remote_hostio_parse_result (char *buffer
, int *retcode
,
11281 int *remote_errno
, char **attachment
)
11286 *attachment
= NULL
;
11288 if (buffer
[0] != 'F')
11292 *retcode
= strtol (&buffer
[1], &p
, 16);
11293 if (errno
!= 0 || p
== &buffer
[1])
11296 /* Check for ",errno". */
11300 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11301 if (errno
!= 0 || p
+ 1 == p2
)
11306 /* Check for ";attachment". If there is no attachment, the
11307 packet should end here. */
11310 *attachment
= p
+ 1;
11313 else if (*p
== '\0')
11319 /* Send a prepared I/O packet to the target and read its response.
11320 The prepared packet is in the global RS->BUF before this function
11321 is called, and the answer is there when we return.
11323 COMMAND_BYTES is the length of the request to send, which may include
11324 binary data. WHICH_PACKET is the packet configuration to check
11325 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11326 is set to the error number and -1 is returned. Otherwise the value
11327 returned by the function is returned.
11329 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11330 attachment is expected; an error will be reported if there's a
11331 mismatch. If one is found, *ATTACHMENT will be set to point into
11332 the packet buffer and *ATTACHMENT_LEN will be set to the
11333 attachment's length. */
11336 remote_hostio_send_command (int command_bytes
, int which_packet
,
11337 int *remote_errno
, char **attachment
,
11338 int *attachment_len
)
11340 struct remote_state
*rs
= get_remote_state ();
11341 int ret
, bytes_read
;
11342 char *attachment_tmp
;
11344 if (!rs
->remote_desc
11345 || packet_support (which_packet
) == PACKET_DISABLE
)
11347 *remote_errno
= FILEIO_ENOSYS
;
11351 putpkt_binary (rs
->buf
, command_bytes
);
11352 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
11354 /* If it timed out, something is wrong. Don't try to parse the
11356 if (bytes_read
< 0)
11358 *remote_errno
= FILEIO_EINVAL
;
11362 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11365 *remote_errno
= FILEIO_EINVAL
;
11367 case PACKET_UNKNOWN
:
11368 *remote_errno
= FILEIO_ENOSYS
;
11374 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
11377 *remote_errno
= FILEIO_EINVAL
;
11381 /* Make sure we saw an attachment if and only if we expected one. */
11382 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11383 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11385 *remote_errno
= FILEIO_EINVAL
;
11389 /* If an attachment was found, it must point into the packet buffer;
11390 work out how many bytes there were. */
11391 if (attachment_tmp
!= NULL
)
11393 *attachment
= attachment_tmp
;
11394 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
11400 /* Invalidate the readahead cache. */
11403 readahead_cache_invalidate (void)
11405 struct remote_state
*rs
= get_remote_state ();
11407 rs
->readahead_cache
.fd
= -1;
11410 /* Invalidate the readahead cache if it is holding data for FD. */
11413 readahead_cache_invalidate_fd (int fd
)
11415 struct remote_state
*rs
= get_remote_state ();
11417 if (rs
->readahead_cache
.fd
== fd
)
11418 rs
->readahead_cache
.fd
= -1;
11421 /* Set the filesystem remote_hostio functions that take FILENAME
11422 arguments will use. Return 0 on success, or -1 if an error
11423 occurs (and set *REMOTE_ERRNO). */
11426 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
11428 struct remote_state
*rs
= get_remote_state ();
11429 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11431 int left
= get_remote_packet_size () - 1;
11435 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11438 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11441 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11443 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11444 remote_buffer_add_string (&p
, &left
, arg
);
11446 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
11447 remote_errno
, NULL
, NULL
);
11449 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11453 rs
->fs_pid
= required_pid
;
11458 /* Implementation of to_fileio_open. */
11461 remote_hostio_open (struct target_ops
*self
,
11462 struct inferior
*inf
, const char *filename
,
11463 int flags
, int mode
, int warn_if_slow
,
11466 struct remote_state
*rs
= get_remote_state ();
11468 int left
= get_remote_packet_size () - 1;
11472 static int warning_issued
= 0;
11474 printf_unfiltered (_("Reading %s from remote target...\n"),
11477 if (!warning_issued
)
11479 warning (_("File transfers from remote targets can be slow."
11480 " Use \"set sysroot\" to access files locally"
11482 warning_issued
= 1;
11486 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11489 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11491 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11492 strlen (filename
));
11493 remote_buffer_add_string (&p
, &left
, ",");
11495 remote_buffer_add_int (&p
, &left
, flags
);
11496 remote_buffer_add_string (&p
, &left
, ",");
11498 remote_buffer_add_int (&p
, &left
, mode
);
11500 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
11501 remote_errno
, NULL
, NULL
);
11504 /* Implementation of to_fileio_pwrite. */
11507 remote_hostio_pwrite (struct target_ops
*self
,
11508 int fd
, const gdb_byte
*write_buf
, int len
,
11509 ULONGEST offset
, int *remote_errno
)
11511 struct remote_state
*rs
= get_remote_state ();
11513 int left
= get_remote_packet_size ();
11516 readahead_cache_invalidate_fd (fd
);
11518 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11520 remote_buffer_add_int (&p
, &left
, fd
);
11521 remote_buffer_add_string (&p
, &left
, ",");
11523 remote_buffer_add_int (&p
, &left
, offset
);
11524 remote_buffer_add_string (&p
, &left
, ",");
11526 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11527 get_remote_packet_size () - (p
- rs
->buf
));
11529 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
11530 remote_errno
, NULL
, NULL
);
11533 /* Helper for the implementation of to_fileio_pread. Read the file
11534 from the remote side with vFile:pread. */
11537 remote_hostio_pread_vFile (struct target_ops
*self
,
11538 int fd
, gdb_byte
*read_buf
, int len
,
11539 ULONGEST offset
, int *remote_errno
)
11541 struct remote_state
*rs
= get_remote_state ();
11544 int left
= get_remote_packet_size ();
11545 int ret
, attachment_len
;
11548 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11550 remote_buffer_add_int (&p
, &left
, fd
);
11551 remote_buffer_add_string (&p
, &left
, ",");
11553 remote_buffer_add_int (&p
, &left
, len
);
11554 remote_buffer_add_string (&p
, &left
, ",");
11556 remote_buffer_add_int (&p
, &left
, offset
);
11558 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
11559 remote_errno
, &attachment
,
11565 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11567 if (read_len
!= ret
)
11568 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11573 /* Serve pread from the readahead cache. Returns number of bytes
11574 read, or 0 if the request can't be served from the cache. */
11577 remote_hostio_pread_from_cache (struct remote_state
*rs
,
11578 int fd
, gdb_byte
*read_buf
, size_t len
,
11581 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11583 if (cache
->fd
== fd
11584 && cache
->offset
<= offset
11585 && offset
< cache
->offset
+ cache
->bufsize
)
11587 ULONGEST max
= cache
->offset
+ cache
->bufsize
;
11589 if (offset
+ len
> max
)
11590 len
= max
- offset
;
11592 memcpy (read_buf
, cache
->buf
+ offset
- cache
->offset
, len
);
11599 /* Implementation of to_fileio_pread. */
11602 remote_hostio_pread (struct target_ops
*self
,
11603 int fd
, gdb_byte
*read_buf
, int len
,
11604 ULONGEST offset
, int *remote_errno
)
11607 struct remote_state
*rs
= get_remote_state ();
11608 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11610 ret
= remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11613 cache
->hit_count
++;
11616 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
11617 pulongest (cache
->hit_count
));
11621 cache
->miss_count
++;
11623 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
11624 pulongest (cache
->miss_count
));
11627 cache
->offset
= offset
;
11628 cache
->bufsize
= get_remote_packet_size ();
11629 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
11631 ret
= remote_hostio_pread_vFile (self
, cache
->fd
, cache
->buf
, cache
->bufsize
,
11632 cache
->offset
, remote_errno
);
11635 readahead_cache_invalidate_fd (fd
);
11639 cache
->bufsize
= ret
;
11640 return remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11643 /* Implementation of to_fileio_close. */
11646 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
11648 struct remote_state
*rs
= get_remote_state ();
11650 int left
= get_remote_packet_size () - 1;
11652 readahead_cache_invalidate_fd (fd
);
11654 remote_buffer_add_string (&p
, &left
, "vFile:close:");
11656 remote_buffer_add_int (&p
, &left
, fd
);
11658 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
11659 remote_errno
, NULL
, NULL
);
11662 /* Implementation of to_fileio_unlink. */
11665 remote_hostio_unlink (struct target_ops
*self
,
11666 struct inferior
*inf
, const char *filename
,
11669 struct remote_state
*rs
= get_remote_state ();
11671 int left
= get_remote_packet_size () - 1;
11673 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11676 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
11678 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11679 strlen (filename
));
11681 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
11682 remote_errno
, NULL
, NULL
);
11685 /* Implementation of to_fileio_readlink. */
11688 remote_hostio_readlink (struct target_ops
*self
,
11689 struct inferior
*inf
, const char *filename
,
11692 struct remote_state
*rs
= get_remote_state ();
11695 int left
= get_remote_packet_size ();
11696 int len
, attachment_len
;
11700 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11703 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
11705 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11706 strlen (filename
));
11708 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
11709 remote_errno
, &attachment
,
11715 ret
= (char *) xmalloc (len
+ 1);
11717 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11718 (gdb_byte
*) ret
, len
);
11719 if (read_len
!= len
)
11720 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
11726 /* Implementation of to_fileio_fstat. */
11729 remote_hostio_fstat (struct target_ops
*self
,
11730 int fd
, struct stat
*st
,
11733 struct remote_state
*rs
= get_remote_state ();
11735 int left
= get_remote_packet_size ();
11736 int attachment_len
, ret
;
11738 struct fio_stat fst
;
11741 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
11743 remote_buffer_add_int (&p
, &left
, fd
);
11745 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
11746 remote_errno
, &attachment
,
11750 if (*remote_errno
!= FILEIO_ENOSYS
)
11753 /* Strictly we should return -1, ENOSYS here, but when
11754 "set sysroot remote:" was implemented in August 2008
11755 BFD's need for a stat function was sidestepped with
11756 this hack. This was not remedied until March 2015
11757 so we retain the previous behavior to avoid breaking
11760 Note that the memset is a March 2015 addition; older
11761 GDBs set st_size *and nothing else* so the structure
11762 would have garbage in all other fields. This might
11763 break something but retaining the previous behavior
11764 here would be just too wrong. */
11766 memset (st
, 0, sizeof (struct stat
));
11767 st
->st_size
= INT_MAX
;
11771 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11772 (gdb_byte
*) &fst
, sizeof (fst
));
11774 if (read_len
!= ret
)
11775 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
11777 if (read_len
!= sizeof (fst
))
11778 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11779 read_len
, (int) sizeof (fst
));
11781 remote_fileio_to_host_stat (&fst
, st
);
11786 /* Implementation of to_filesystem_is_local. */
11789 remote_filesystem_is_local (struct target_ops
*self
)
11791 /* Valgrind GDB presents itself as a remote target but works
11792 on the local filesystem: it does not implement remote get
11793 and users are not expected to set a sysroot. To handle
11794 this case we treat the remote filesystem as local if the
11795 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11796 does not support vFile:open. */
11797 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
11799 enum packet_support ps
= packet_support (PACKET_vFile_open
);
11801 if (ps
== PACKET_SUPPORT_UNKNOWN
)
11803 int fd
, remote_errno
;
11805 /* Try opening a file to probe support. The supplied
11806 filename is irrelevant, we only care about whether
11807 the stub recognizes the packet or not. */
11808 fd
= remote_hostio_open (self
, NULL
, "just probing",
11809 FILEIO_O_RDONLY
, 0700, 0,
11813 remote_hostio_close (self
, fd
, &remote_errno
);
11815 ps
= packet_support (PACKET_vFile_open
);
11818 if (ps
== PACKET_DISABLE
)
11820 static int warning_issued
= 0;
11822 if (!warning_issued
)
11824 warning (_("remote target does not support file"
11825 " transfer, attempting to access files"
11826 " from local filesystem."));
11827 warning_issued
= 1;
11838 remote_fileio_errno_to_host (int errnum
)
11844 case FILEIO_ENOENT
:
11852 case FILEIO_EACCES
:
11854 case FILEIO_EFAULT
:
11858 case FILEIO_EEXIST
:
11860 case FILEIO_ENODEV
:
11862 case FILEIO_ENOTDIR
:
11864 case FILEIO_EISDIR
:
11866 case FILEIO_EINVAL
:
11868 case FILEIO_ENFILE
:
11870 case FILEIO_EMFILE
:
11874 case FILEIO_ENOSPC
:
11876 case FILEIO_ESPIPE
:
11880 case FILEIO_ENOSYS
:
11882 case FILEIO_ENAMETOOLONG
:
11883 return ENAMETOOLONG
;
11889 remote_hostio_error (int errnum
)
11891 int host_error
= remote_fileio_errno_to_host (errnum
);
11893 if (host_error
== -1)
11894 error (_("Unknown remote I/O error %d"), errnum
);
11896 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
11900 remote_hostio_close_cleanup (void *opaque
)
11902 int fd
= *(int *) opaque
;
11905 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
11909 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
11911 struct cleanup
*back_to
, *close_cleanup
;
11912 int retcode
, fd
, remote_errno
, bytes
, io_size
;
11915 int bytes_in_buffer
;
11918 struct remote_state
*rs
= get_remote_state ();
11920 if (!rs
->remote_desc
)
11921 error (_("command can only be used with remote target"));
11923 file
= gdb_fopen_cloexec (local_file
, "rb");
11925 perror_with_name (local_file
);
11926 back_to
= make_cleanup_fclose (file
);
11928 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11929 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
11931 0700, 0, &remote_errno
);
11933 remote_hostio_error (remote_errno
);
11935 /* Send up to this many bytes at once. They won't all fit in the
11936 remote packet limit, so we'll transfer slightly fewer. */
11937 io_size
= get_remote_packet_size ();
11938 buffer
= (gdb_byte
*) xmalloc (io_size
);
11939 make_cleanup (xfree
, buffer
);
11941 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11943 bytes_in_buffer
= 0;
11946 while (bytes_in_buffer
|| !saw_eof
)
11950 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
11951 io_size
- bytes_in_buffer
,
11956 error (_("Error reading %s."), local_file
);
11959 /* EOF. Unless there is something still in the
11960 buffer from the last iteration, we are done. */
11962 if (bytes_in_buffer
== 0)
11970 bytes
+= bytes_in_buffer
;
11971 bytes_in_buffer
= 0;
11973 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
11975 offset
, &remote_errno
);
11978 remote_hostio_error (remote_errno
);
11979 else if (retcode
== 0)
11980 error (_("Remote write of %d bytes returned 0!"), bytes
);
11981 else if (retcode
< bytes
)
11983 /* Short write. Save the rest of the read data for the next
11985 bytes_in_buffer
= bytes
- retcode
;
11986 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
11992 discard_cleanups (close_cleanup
);
11993 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
11994 remote_hostio_error (remote_errno
);
11997 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
11998 do_cleanups (back_to
);
12002 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12004 struct cleanup
*back_to
, *close_cleanup
;
12005 int fd
, remote_errno
, bytes
, io_size
;
12009 struct remote_state
*rs
= get_remote_state ();
12011 if (!rs
->remote_desc
)
12012 error (_("command can only be used with remote target"));
12014 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
12015 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12018 remote_hostio_error (remote_errno
);
12020 file
= gdb_fopen_cloexec (local_file
, "wb");
12022 perror_with_name (local_file
);
12023 back_to
= make_cleanup_fclose (file
);
12025 /* Send up to this many bytes at once. They won't all fit in the
12026 remote packet limit, so we'll transfer slightly fewer. */
12027 io_size
= get_remote_packet_size ();
12028 buffer
= (gdb_byte
*) xmalloc (io_size
);
12029 make_cleanup (xfree
, buffer
);
12031 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
12036 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
12037 fd
, buffer
, io_size
, offset
, &remote_errno
);
12039 /* Success, but no bytes, means end-of-file. */
12042 remote_hostio_error (remote_errno
);
12046 bytes
= fwrite (buffer
, 1, bytes
, file
);
12048 perror_with_name (local_file
);
12051 discard_cleanups (close_cleanup
);
12052 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12053 remote_hostio_error (remote_errno
);
12056 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12057 do_cleanups (back_to
);
12061 remote_file_delete (const char *remote_file
, int from_tty
)
12063 int retcode
, remote_errno
;
12064 struct remote_state
*rs
= get_remote_state ();
12066 if (!rs
->remote_desc
)
12067 error (_("command can only be used with remote target"));
12069 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
12070 NULL
, remote_file
, &remote_errno
);
12072 remote_hostio_error (remote_errno
);
12075 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12079 remote_put_command (char *args
, int from_tty
)
12081 struct cleanup
*back_to
;
12085 error_no_arg (_("file to put"));
12087 argv
= gdb_buildargv (args
);
12088 back_to
= make_cleanup_freeargv (argv
);
12089 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12090 error (_("Invalid parameters to remote put"));
12092 remote_file_put (argv
[0], argv
[1], from_tty
);
12094 do_cleanups (back_to
);
12098 remote_get_command (char *args
, int from_tty
)
12100 struct cleanup
*back_to
;
12104 error_no_arg (_("file to get"));
12106 argv
= gdb_buildargv (args
);
12107 back_to
= make_cleanup_freeargv (argv
);
12108 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12109 error (_("Invalid parameters to remote get"));
12111 remote_file_get (argv
[0], argv
[1], from_tty
);
12113 do_cleanups (back_to
);
12117 remote_delete_command (char *args
, int from_tty
)
12119 struct cleanup
*back_to
;
12123 error_no_arg (_("file to delete"));
12125 argv
= gdb_buildargv (args
);
12126 back_to
= make_cleanup_freeargv (argv
);
12127 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12128 error (_("Invalid parameters to remote delete"));
12130 remote_file_delete (argv
[0], from_tty
);
12132 do_cleanups (back_to
);
12136 remote_command (char *args
, int from_tty
)
12138 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12142 remote_can_execute_reverse (struct target_ops
*self
)
12144 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12145 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12152 remote_supports_non_stop (struct target_ops
*self
)
12158 remote_supports_disable_randomization (struct target_ops
*self
)
12160 /* Only supported in extended mode. */
12165 remote_supports_multi_process (struct target_ops
*self
)
12167 struct remote_state
*rs
= get_remote_state ();
12169 return remote_multi_process_p (rs
);
12173 remote_supports_cond_tracepoints (void)
12175 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12179 remote_supports_cond_breakpoints (struct target_ops
*self
)
12181 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12185 remote_supports_fast_tracepoints (void)
12187 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12191 remote_supports_static_tracepoints (void)
12193 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12197 remote_supports_install_in_trace (void)
12199 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12203 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
12205 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12210 remote_supports_string_tracing (struct target_ops
*self
)
12212 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12216 remote_can_run_breakpoint_commands (struct target_ops
*self
)
12218 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12222 remote_trace_init (struct target_ops
*self
)
12225 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12226 if (strcmp (target_buf
, "OK") != 0)
12227 error (_("Target does not support this command."));
12230 static void free_actions_list (char **actions_list
);
12231 static void free_actions_list_cleanup_wrapper (void *);
12233 free_actions_list_cleanup_wrapper (void *al
)
12235 free_actions_list ((char **) al
);
12239 free_actions_list (char **actions_list
)
12243 if (actions_list
== 0)
12246 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
12247 xfree (actions_list
[ndx
]);
12249 xfree (actions_list
);
12252 /* Recursive routine to walk through command list including loops, and
12253 download packets for each command. */
12256 remote_download_command_source (int num
, ULONGEST addr
,
12257 struct command_line
*cmds
)
12259 struct remote_state
*rs
= get_remote_state ();
12260 struct command_line
*cmd
;
12262 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12264 QUIT
; /* Allow user to bail out with ^C. */
12265 strcpy (rs
->buf
, "QTDPsrc:");
12266 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12267 rs
->buf
+ strlen (rs
->buf
),
12268 rs
->buf_size
- strlen (rs
->buf
));
12270 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12271 if (strcmp (target_buf
, "OK"))
12272 warning (_("Target does not support source download."));
12274 if (cmd
->control_type
== while_control
12275 || cmd
->control_type
== while_stepping_control
)
12277 remote_download_command_source (num
, addr
, *cmd
->body_list
);
12279 QUIT
; /* Allow user to bail out with ^C. */
12280 strcpy (rs
->buf
, "QTDPsrc:");
12281 encode_source_string (num
, addr
, "cmd", "end",
12282 rs
->buf
+ strlen (rs
->buf
),
12283 rs
->buf_size
- strlen (rs
->buf
));
12285 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12286 if (strcmp (target_buf
, "OK"))
12287 warning (_("Target does not support source download."));
12293 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
12295 #define BUF_SIZE 2048
12299 char buf
[BUF_SIZE
];
12300 char **tdp_actions
;
12301 char **stepping_actions
;
12303 struct cleanup
*old_chain
= NULL
;
12305 struct breakpoint
*b
= loc
->owner
;
12306 struct tracepoint
*t
= (struct tracepoint
*) b
;
12308 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12309 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
12311 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
12314 tpaddr
= loc
->address
;
12315 sprintf_vma (addrbuf
, tpaddr
);
12316 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
12317 addrbuf
, /* address */
12318 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12319 t
->step_count
, t
->pass_count
);
12320 /* Fast tracepoints are mostly handled by the target, but we can
12321 tell the target how big of an instruction block should be moved
12323 if (b
->type
== bp_fast_tracepoint
)
12325 /* Only test for support at download time; we may not know
12326 target capabilities at definition time. */
12327 if (remote_supports_fast_tracepoints ())
12329 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12331 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
12332 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12334 /* If it passed validation at definition but fails now,
12335 something is very wrong. */
12336 internal_error (__FILE__
, __LINE__
,
12337 _("Fast tracepoint not "
12338 "valid during download"));
12341 /* Fast tracepoints are functionally identical to regular
12342 tracepoints, so don't take lack of support as a reason to
12343 give up on the trace run. */
12344 warning (_("Target does not support fast tracepoints, "
12345 "downloading %d as regular tracepoint"), b
->number
);
12347 else if (b
->type
== bp_static_tracepoint
)
12349 /* Only test for support at download time; we may not know
12350 target capabilities at definition time. */
12351 if (remote_supports_static_tracepoints ())
12353 struct static_tracepoint_marker marker
;
12355 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12356 strcat (buf
, ":S");
12358 error (_("Static tracepoint not valid during download"));
12361 /* Fast tracepoints are functionally identical to regular
12362 tracepoints, so don't take lack of support as a reason
12363 to give up on the trace run. */
12364 error (_("Target does not support static tracepoints"));
12366 /* If the tracepoint has a conditional, make it into an agent
12367 expression and append to the definition. */
12370 /* Only test support at download time, we may not know target
12371 capabilities at definition time. */
12372 if (remote_supports_cond_tracepoints ())
12374 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
.get ());
12375 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
12377 pkt
= buf
+ strlen (buf
);
12378 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12379 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12383 warning (_("Target does not support conditional tracepoints, "
12384 "ignoring tp %d cond"), b
->number
);
12387 if (b
->commands
|| *default_collect
)
12390 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12391 if (strcmp (target_buf
, "OK"))
12392 error (_("Target does not support tracepoints."));
12394 /* do_single_steps (t); */
12397 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
12399 QUIT
; /* Allow user to bail out with ^C. */
12400 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
12401 b
->number
, addrbuf
, /* address */
12403 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
12406 remote_get_noisy_reply (&target_buf
,
12408 if (strcmp (target_buf
, "OK"))
12409 error (_("Error on target while setting tracepoints."));
12412 if (stepping_actions
)
12414 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
12416 QUIT
; /* Allow user to bail out with ^C. */
12417 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
12418 b
->number
, addrbuf
, /* address */
12419 ((ndx
== 0) ? "S" : ""),
12420 stepping_actions
[ndx
],
12421 (stepping_actions
[ndx
+ 1] ? "-" : ""));
12423 remote_get_noisy_reply (&target_buf
,
12425 if (strcmp (target_buf
, "OK"))
12426 error (_("Error on target while setting tracepoints."));
12430 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12432 if (b
->location
!= NULL
)
12434 strcpy (buf
, "QTDPsrc:");
12435 encode_source_string (b
->number
, loc
->address
, "at",
12436 event_location_to_string (b
->location
.get ()),
12437 buf
+ strlen (buf
), 2048 - strlen (buf
));
12439 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12440 if (strcmp (target_buf
, "OK"))
12441 warning (_("Target does not support source download."));
12443 if (b
->cond_string
)
12445 strcpy (buf
, "QTDPsrc:");
12446 encode_source_string (b
->number
, loc
->address
,
12447 "cond", b
->cond_string
, buf
+ strlen (buf
),
12448 2048 - strlen (buf
));
12450 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12451 if (strcmp (target_buf
, "OK"))
12452 warning (_("Target does not support source download."));
12454 remote_download_command_source (b
->number
, loc
->address
,
12455 breakpoint_commands (b
));
12458 do_cleanups (old_chain
);
12462 remote_can_download_tracepoint (struct target_ops
*self
)
12464 struct remote_state
*rs
= get_remote_state ();
12465 struct trace_status
*ts
;
12468 /* Don't try to install tracepoints until we've relocated our
12469 symbols, and fetched and merged the target's tracepoint list with
12471 if (rs
->starting_up
)
12474 ts
= current_trace_status ();
12475 status
= remote_get_trace_status (self
, ts
);
12477 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12480 /* If we are in a tracing experiment, but remote stub doesn't support
12481 installing tracepoint in trace, we have to return. */
12482 if (!remote_supports_install_in_trace ())
12490 remote_download_trace_state_variable (struct target_ops
*self
,
12491 struct trace_state_variable
*tsv
)
12493 struct remote_state
*rs
= get_remote_state ();
12496 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12497 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
12499 p
= rs
->buf
+ strlen (rs
->buf
);
12500 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
12501 error (_("Trace state variable name too long for tsv definition packet"));
12502 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
12505 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12506 if (*target_buf
== '\0')
12507 error (_("Target does not support this command."));
12508 if (strcmp (target_buf
, "OK") != 0)
12509 error (_("Error on target while downloading trace state variable."));
12513 remote_enable_tracepoint (struct target_ops
*self
,
12514 struct bp_location
*location
)
12516 struct remote_state
*rs
= get_remote_state ();
12519 sprintf_vma (addr_buf
, location
->address
);
12520 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
12521 location
->owner
->number
, addr_buf
);
12523 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12524 if (*rs
->buf
== '\0')
12525 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12526 if (strcmp (rs
->buf
, "OK") != 0)
12527 error (_("Error on target while enabling tracepoint."));
12531 remote_disable_tracepoint (struct target_ops
*self
,
12532 struct bp_location
*location
)
12534 struct remote_state
*rs
= get_remote_state ();
12537 sprintf_vma (addr_buf
, location
->address
);
12538 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
12539 location
->owner
->number
, addr_buf
);
12541 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12542 if (*rs
->buf
== '\0')
12543 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12544 if (strcmp (rs
->buf
, "OK") != 0)
12545 error (_("Error on target while disabling tracepoint."));
12549 remote_trace_set_readonly_regions (struct target_ops
*self
)
12553 bfd_size_type size
;
12559 return; /* No information to give. */
12561 strcpy (target_buf
, "QTro");
12562 offset
= strlen (target_buf
);
12563 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
12565 char tmp1
[40], tmp2
[40];
12568 if ((s
->flags
& SEC_LOAD
) == 0 ||
12569 /* (s->flags & SEC_CODE) == 0 || */
12570 (s
->flags
& SEC_READONLY
) == 0)
12574 vma
= bfd_get_section_vma (abfd
, s
);
12575 size
= bfd_get_section_size (s
);
12576 sprintf_vma (tmp1
, vma
);
12577 sprintf_vma (tmp2
, vma
+ size
);
12578 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
12579 if (offset
+ sec_length
+ 1 > target_buf_size
)
12581 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
12583 Too many sections for read-only sections definition packet."));
12586 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
12588 offset
+= sec_length
;
12592 putpkt (target_buf
);
12593 getpkt (&target_buf
, &target_buf_size
, 0);
12598 remote_trace_start (struct target_ops
*self
)
12600 putpkt ("QTStart");
12601 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12602 if (*target_buf
== '\0')
12603 error (_("Target does not support this command."));
12604 if (strcmp (target_buf
, "OK") != 0)
12605 error (_("Bogus reply from target: %s"), target_buf
);
12609 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
12611 /* Initialize it just to avoid a GCC false warning. */
12613 /* FIXME we need to get register block size some other way. */
12614 extern int trace_regblock_size
;
12615 enum packet_result result
;
12617 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
12620 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
12622 putpkt ("qTStatus");
12626 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12628 CATCH (ex
, RETURN_MASK_ERROR
)
12630 if (ex
.error
!= TARGET_CLOSE_ERROR
)
12632 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
12635 throw_exception (ex
);
12639 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
12641 /* If the remote target doesn't do tracing, flag it. */
12642 if (result
== PACKET_UNKNOWN
)
12645 /* We're working with a live target. */
12646 ts
->filename
= NULL
;
12649 error (_("Bogus trace status reply from target: %s"), target_buf
);
12651 /* Function 'parse_trace_status' sets default value of each field of
12652 'ts' at first, so we don't have to do it here. */
12653 parse_trace_status (p
, ts
);
12655 return ts
->running
;
12659 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
12660 struct uploaded_tp
*utp
)
12662 struct remote_state
*rs
= get_remote_state ();
12664 struct bp_location
*loc
;
12665 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
12666 size_t size
= get_remote_packet_size ();
12671 tp
->traceframe_usage
= 0;
12672 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
12674 /* If the tracepoint was never downloaded, don't go asking for
12676 if (tp
->number_on_target
== 0)
12678 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
12679 phex_nz (loc
->address
, 0));
12681 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12682 if (reply
&& *reply
)
12685 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12691 utp
->hit_count
= 0;
12692 utp
->traceframe_usage
= 0;
12693 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
12694 phex_nz (utp
->addr
, 0));
12696 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12697 if (reply
&& *reply
)
12700 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12706 remote_trace_stop (struct target_ops
*self
)
12709 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12710 if (*target_buf
== '\0')
12711 error (_("Target does not support this command."));
12712 if (strcmp (target_buf
, "OK") != 0)
12713 error (_("Bogus reply from target: %s"), target_buf
);
12717 remote_trace_find (struct target_ops
*self
,
12718 enum trace_find_type type
, int num
,
12719 CORE_ADDR addr1
, CORE_ADDR addr2
,
12722 struct remote_state
*rs
= get_remote_state ();
12723 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12725 int target_frameno
= -1, target_tracept
= -1;
12727 /* Lookups other than by absolute frame number depend on the current
12728 trace selected, so make sure it is correct on the remote end
12730 if (type
!= tfind_number
)
12731 set_remote_traceframe ();
12734 strcpy (p
, "QTFrame:");
12735 p
= strchr (p
, '\0');
12739 xsnprintf (p
, endbuf
- p
, "%x", num
);
12742 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
12745 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
12748 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
12749 phex_nz (addr2
, 0));
12751 case tfind_outside
:
12752 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
12753 phex_nz (addr2
, 0));
12756 error (_("Unknown trace find type %d"), type
);
12760 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
12761 if (*reply
== '\0')
12762 error (_("Target does not support this command."));
12764 while (reply
&& *reply
)
12769 target_frameno
= (int) strtol (p
, &reply
, 16);
12771 error (_("Unable to parse trace frame number"));
12772 /* Don't update our remote traceframe number cache on failure
12773 to select a remote traceframe. */
12774 if (target_frameno
== -1)
12779 target_tracept
= (int) strtol (p
, &reply
, 16);
12781 error (_("Unable to parse tracepoint number"));
12783 case 'O': /* "OK"? */
12784 if (reply
[1] == 'K' && reply
[2] == '\0')
12787 error (_("Bogus reply from target: %s"), reply
);
12790 error (_("Bogus reply from target: %s"), reply
);
12793 *tpp
= target_tracept
;
12795 rs
->remote_traceframe_number
= target_frameno
;
12796 return target_frameno
;
12800 remote_get_trace_state_variable_value (struct target_ops
*self
,
12801 int tsvnum
, LONGEST
*val
)
12803 struct remote_state
*rs
= get_remote_state ();
12807 set_remote_traceframe ();
12809 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
12811 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12812 if (reply
&& *reply
)
12816 unpack_varlen_hex (reply
+ 1, &uval
);
12817 *val
= (LONGEST
) uval
;
12825 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
12827 struct remote_state
*rs
= get_remote_state ();
12831 strcpy (p
, "QTSave:");
12833 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
12834 error (_("Remote file name too long for trace save packet"));
12835 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
12838 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12839 if (*reply
== '\0')
12840 error (_("Target does not support this command."));
12841 if (strcmp (reply
, "OK") != 0)
12842 error (_("Bogus reply from target: %s"), reply
);
12846 /* This is basically a memory transfer, but needs to be its own packet
12847 because we don't know how the target actually organizes its trace
12848 memory, plus we want to be able to ask for as much as possible, but
12849 not be unhappy if we don't get as much as we ask for. */
12852 remote_get_raw_trace_data (struct target_ops
*self
,
12853 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
12855 struct remote_state
*rs
= get_remote_state ();
12861 strcpy (p
, "qTBuffer:");
12863 p
+= hexnumstr (p
, offset
);
12865 p
+= hexnumstr (p
, len
);
12869 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12870 if (reply
&& *reply
)
12872 /* 'l' by itself means we're at the end of the buffer and
12873 there is nothing more to get. */
12877 /* Convert the reply into binary. Limit the number of bytes to
12878 convert according to our passed-in buffer size, rather than
12879 what was returned in the packet; if the target is
12880 unexpectedly generous and gives us a bigger reply than we
12881 asked for, we don't want to crash. */
12882 rslt
= hex2bin (target_buf
, buf
, len
);
12886 /* Something went wrong, flag as an error. */
12891 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
12893 struct remote_state
*rs
= get_remote_state ();
12895 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
12899 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
12901 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12902 if (*reply
== '\0')
12903 error (_("Target does not support this command."));
12904 if (strcmp (reply
, "OK") != 0)
12905 error (_("Bogus reply from target: %s"), reply
);
12908 warning (_("Target does not support disconnected tracing."));
12912 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
12914 struct thread_info
*info
= find_thread_ptid (ptid
);
12916 if (info
&& info
->priv
)
12917 return info
->priv
->core
;
12922 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
12924 struct remote_state
*rs
= get_remote_state ();
12927 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
12929 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12930 if (*reply
== '\0')
12931 error (_("Target does not support this command."));
12932 if (strcmp (reply
, "OK") != 0)
12933 error (_("Bogus reply from target: %s"), reply
);
12936 static struct traceframe_info
*
12937 remote_traceframe_info (struct target_ops
*self
)
12941 text
= target_read_stralloc (¤t_target
,
12942 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
12945 struct traceframe_info
*info
;
12946 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
12948 info
= parse_traceframe_info (text
);
12949 do_cleanups (back_to
);
12956 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12957 instruction on which a fast tracepoint may be placed. Returns -1
12958 if the packet is not supported, and 0 if the minimum instruction
12959 length is unknown. */
12962 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
12964 struct remote_state
*rs
= get_remote_state ();
12967 /* If we're not debugging a process yet, the IPA can't be
12969 if (!target_has_execution
)
12972 /* Make sure the remote is pointing at the right process. */
12973 set_general_process ();
12975 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
12977 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12978 if (*reply
== '\0')
12982 ULONGEST min_insn_len
;
12984 unpack_varlen_hex (reply
, &min_insn_len
);
12986 return (int) min_insn_len
;
12991 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
12993 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
12995 struct remote_state
*rs
= get_remote_state ();
12996 char *buf
= rs
->buf
;
12997 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12998 enum packet_result result
;
13000 gdb_assert (val
>= 0 || val
== -1);
13001 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13002 /* Send -1 as literal "-1" to avoid host size dependency. */
13006 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13009 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13012 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
13013 result
= packet_ok (rs
->buf
,
13014 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13016 if (result
!= PACKET_OK
)
13017 warning (_("Bogus reply from target: %s"), rs
->buf
);
13022 remote_set_trace_notes (struct target_ops
*self
,
13023 const char *user
, const char *notes
,
13024 const char *stop_notes
)
13026 struct remote_state
*rs
= get_remote_state ();
13028 char *buf
= rs
->buf
;
13029 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13032 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13035 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13036 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13042 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13043 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13049 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13050 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13054 /* Ensure the buffer is terminated. */
13058 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
13059 if (*reply
== '\0')
13062 if (strcmp (reply
, "OK") != 0)
13063 error (_("Bogus reply from target: %s"), reply
);
13069 remote_use_agent (struct target_ops
*self
, int use
)
13071 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13073 struct remote_state
*rs
= get_remote_state ();
13075 /* If the stub supports QAgent. */
13076 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
13078 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13080 if (strcmp (rs
->buf
, "OK") == 0)
13091 remote_can_use_agent (struct target_ops
*self
)
13093 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13096 struct btrace_target_info
13098 /* The ptid of the traced thread. */
13101 /* The obtained branch trace configuration. */
13102 struct btrace_config conf
;
13105 /* Reset our idea of our target's btrace configuration. */
13108 remote_btrace_reset (void)
13110 struct remote_state
*rs
= get_remote_state ();
13112 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13115 /* Check whether the target supports branch tracing. */
13118 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
13120 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
13122 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
13127 case BTRACE_FORMAT_NONE
:
13130 case BTRACE_FORMAT_BTS
:
13131 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
13133 case BTRACE_FORMAT_PT
:
13134 /* The trace is decoded on the host. Even if our target supports it,
13135 we still need to have libipt to decode the trace. */
13136 #if defined (HAVE_LIBIPT)
13137 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
13138 #else /* !defined (HAVE_LIBIPT) */
13140 #endif /* !defined (HAVE_LIBIPT) */
13143 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
13146 /* Synchronize the configuration with the target. */
13149 btrace_sync_conf (const struct btrace_config
*conf
)
13151 struct packet_config
*packet
;
13152 struct remote_state
*rs
;
13153 char *buf
, *pos
, *endbuf
;
13155 rs
= get_remote_state ();
13157 endbuf
= buf
+ get_remote_packet_size ();
13159 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13160 if (packet_config_support (packet
) == PACKET_ENABLE
13161 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13164 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13168 getpkt (&buf
, &rs
->buf_size
, 0);
13170 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13172 if (buf
[0] == 'E' && buf
[1] == '.')
13173 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13175 error (_("Failed to configure the BTS buffer size."));
13178 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13181 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13182 if (packet_config_support (packet
) == PACKET_ENABLE
13183 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13186 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13190 getpkt (&buf
, &rs
->buf_size
, 0);
13192 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13194 if (buf
[0] == 'E' && buf
[1] == '.')
13195 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13197 error (_("Failed to configure the trace buffer size."));
13200 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13204 /* Read the current thread's btrace configuration from the target and
13205 store it into CONF. */
13208 btrace_read_config (struct btrace_config
*conf
)
13212 xml
= target_read_stralloc (¤t_target
,
13213 TARGET_OBJECT_BTRACE_CONF
, "");
13216 struct cleanup
*cleanup
;
13218 cleanup
= make_cleanup (xfree
, xml
);
13219 parse_xml_btrace_conf (conf
, xml
);
13220 do_cleanups (cleanup
);
13224 /* Maybe reopen target btrace. */
13227 remote_btrace_maybe_reopen (void)
13229 struct remote_state
*rs
= get_remote_state ();
13230 struct thread_info
*tp
;
13231 int btrace_target_pushed
= 0;
13234 scoped_restore_current_thread restore_thread
;
13236 ALL_NON_EXITED_THREADS (tp
)
13238 set_general_thread (tp
->ptid
);
13240 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13241 btrace_read_config (&rs
->btrace_config
);
13243 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13246 #if !defined (HAVE_LIBIPT)
13247 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13252 warning (_("GDB does not support Intel Processor Trace. "
13253 "\"record\" will not work in this session."));
13258 #endif /* !defined (HAVE_LIBIPT) */
13260 /* Push target, once, but before anything else happens. This way our
13261 changes to the threads will be cleaned up by unpushing the target
13262 in case btrace_read_config () throws. */
13263 if (!btrace_target_pushed
)
13265 btrace_target_pushed
= 1;
13266 record_btrace_push_target ();
13267 printf_filtered (_("Target is recording using %s.\n"),
13268 btrace_format_string (rs
->btrace_config
.format
));
13271 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13272 tp
->btrace
.target
->ptid
= tp
->ptid
;
13273 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13277 /* Enable branch tracing. */
13279 static struct btrace_target_info
*
13280 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
13281 const struct btrace_config
*conf
)
13283 struct btrace_target_info
*tinfo
= NULL
;
13284 struct packet_config
*packet
= NULL
;
13285 struct remote_state
*rs
= get_remote_state ();
13286 char *buf
= rs
->buf
;
13287 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13289 switch (conf
->format
)
13291 case BTRACE_FORMAT_BTS
:
13292 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13295 case BTRACE_FORMAT_PT
:
13296 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13300 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13301 error (_("Target does not support branch tracing."));
13303 btrace_sync_conf (conf
);
13305 set_general_thread (ptid
);
13307 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13309 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13311 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13313 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13314 error (_("Could not enable branch tracing for %s: %s"),
13315 target_pid_to_str (ptid
), rs
->buf
+ 2);
13317 error (_("Could not enable branch tracing for %s."),
13318 target_pid_to_str (ptid
));
13321 tinfo
= XCNEW (struct btrace_target_info
);
13322 tinfo
->ptid
= ptid
;
13324 /* If we fail to read the configuration, we lose some information, but the
13325 tracing itself is not impacted. */
13328 btrace_read_config (&tinfo
->conf
);
13330 CATCH (err
, RETURN_MASK_ERROR
)
13332 if (err
.message
!= NULL
)
13333 warning ("%s", err
.message
);
13340 /* Disable branch tracing. */
13343 remote_disable_btrace (struct target_ops
*self
,
13344 struct btrace_target_info
*tinfo
)
13346 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13347 struct remote_state
*rs
= get_remote_state ();
13348 char *buf
= rs
->buf
;
13349 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13351 if (packet_config_support (packet
) != PACKET_ENABLE
)
13352 error (_("Target does not support branch tracing."));
13354 set_general_thread (tinfo
->ptid
);
13356 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13358 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13360 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13362 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13363 error (_("Could not disable branch tracing for %s: %s"),
13364 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
13366 error (_("Could not disable branch tracing for %s."),
13367 target_pid_to_str (tinfo
->ptid
));
13373 /* Teardown branch tracing. */
13376 remote_teardown_btrace (struct target_ops
*self
,
13377 struct btrace_target_info
*tinfo
)
13379 /* We must not talk to the target during teardown. */
13383 /* Read the branch trace. */
13385 static enum btrace_error
13386 remote_read_btrace (struct target_ops
*self
,
13387 struct btrace_data
*btrace
,
13388 struct btrace_target_info
*tinfo
,
13389 enum btrace_read_type type
)
13391 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13392 struct cleanup
*cleanup
;
13396 if (packet_config_support (packet
) != PACKET_ENABLE
)
13397 error (_("Target does not support branch tracing."));
13399 #if !defined(HAVE_LIBEXPAT)
13400 error (_("Cannot process branch tracing result. XML parsing not supported."));
13405 case BTRACE_READ_ALL
:
13408 case BTRACE_READ_NEW
:
13411 case BTRACE_READ_DELTA
:
13415 internal_error (__FILE__
, __LINE__
,
13416 _("Bad branch tracing read type: %u."),
13417 (unsigned int) type
);
13420 xml
= target_read_stralloc (¤t_target
,
13421 TARGET_OBJECT_BTRACE
, annex
);
13423 return BTRACE_ERR_UNKNOWN
;
13425 cleanup
= make_cleanup (xfree
, xml
);
13426 parse_xml_btrace (btrace
, xml
);
13427 do_cleanups (cleanup
);
13429 return BTRACE_ERR_NONE
;
13432 static const struct btrace_config
*
13433 remote_btrace_conf (struct target_ops
*self
,
13434 const struct btrace_target_info
*tinfo
)
13436 return &tinfo
->conf
;
13440 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
13442 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13446 /* Implementation of to_load. */
13449 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
13451 generic_load (name
, from_tty
);
13454 /* Accepts an integer PID; returns a string representing a file that
13455 can be opened on the remote side to get the symbols for the child
13456 process. Returns NULL if the operation is not supported. */
13459 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
13461 static char *filename
= NULL
;
13462 struct inferior
*inf
;
13463 char *annex
= NULL
;
13465 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13468 if (filename
!= NULL
)
13471 inf
= find_inferior_pid (pid
);
13473 internal_error (__FILE__
, __LINE__
,
13474 _("not currently attached to process %d"), pid
);
13476 if (!inf
->fake_pid_p
)
13478 const int annex_size
= 9;
13480 annex
= (char *) alloca (annex_size
);
13481 xsnprintf (annex
, annex_size
, "%x", pid
);
13484 filename
= target_read_stralloc (¤t_target
,
13485 TARGET_OBJECT_EXEC_FILE
, annex
);
13490 /* Implement the to_can_do_single_step target_ops method. */
13493 remote_can_do_single_step (struct target_ops
*ops
)
13495 /* We can only tell whether target supports single step or not by
13496 supported s and S vCont actions if the stub supports vContSupported
13497 feature. If the stub doesn't support vContSupported feature,
13498 we have conservatively to think target doesn't supports single
13500 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13502 struct remote_state
*rs
= get_remote_state ();
13504 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13505 remote_vcont_probe (rs
);
13507 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13513 /* Implementation of the to_execution_direction method for the remote
13516 static enum exec_direction_kind
13517 remote_execution_direction (struct target_ops
*self
)
13519 struct remote_state
*rs
= get_remote_state ();
13521 return rs
->last_resume_exec_dir
;
13525 init_remote_ops (void)
13527 remote_ops
.to_shortname
= "remote";
13528 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
13529 remote_ops
.to_doc
=
13530 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13531 Specify the serial device it is connected to\n\
13532 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13533 remote_ops
.to_open
= remote_open
;
13534 remote_ops
.to_close
= remote_close
;
13535 remote_ops
.to_detach
= remote_detach
;
13536 remote_ops
.to_disconnect
= remote_disconnect
;
13537 remote_ops
.to_resume
= remote_resume
;
13538 remote_ops
.to_commit_resume
= remote_commit_resume
;
13539 remote_ops
.to_wait
= remote_wait
;
13540 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
13541 remote_ops
.to_store_registers
= remote_store_registers
;
13542 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
13543 remote_ops
.to_files_info
= remote_files_info
;
13544 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
13545 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
13546 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
13547 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
13548 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
13549 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
13550 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
13551 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
13552 remote_ops
.to_watchpoint_addr_within_range
=
13553 remote_watchpoint_addr_within_range
;
13554 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
13555 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
13556 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
13557 remote_ops
.to_region_ok_for_hw_watchpoint
13558 = remote_region_ok_for_hw_watchpoint
;
13559 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
13560 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
13561 remote_ops
.to_kill
= remote_kill
;
13562 remote_ops
.to_load
= remote_load
;
13563 remote_ops
.to_mourn_inferior
= remote_mourn
;
13564 remote_ops
.to_pass_signals
= remote_pass_signals
;
13565 remote_ops
.to_set_syscall_catchpoint
= remote_set_syscall_catchpoint
;
13566 remote_ops
.to_program_signals
= remote_program_signals
;
13567 remote_ops
.to_thread_alive
= remote_thread_alive
;
13568 remote_ops
.to_thread_name
= remote_thread_name
;
13569 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
13570 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
13571 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
13572 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
13573 remote_ops
.to_stop
= remote_stop
;
13574 remote_ops
.to_interrupt
= remote_interrupt
;
13575 remote_ops
.to_pass_ctrlc
= remote_pass_ctrlc
;
13576 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
13577 remote_ops
.to_get_memory_xfer_limit
= remote_get_memory_xfer_limit
;
13578 remote_ops
.to_rcmd
= remote_rcmd
;
13579 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
13580 remote_ops
.to_log_command
= serial_log_command
;
13581 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
13582 remote_ops
.to_stratum
= process_stratum
;
13583 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
13584 remote_ops
.to_has_memory
= default_child_has_memory
;
13585 remote_ops
.to_has_stack
= default_child_has_stack
;
13586 remote_ops
.to_has_registers
= default_child_has_registers
;
13587 remote_ops
.to_has_execution
= default_child_has_execution
;
13588 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
13589 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
13590 remote_ops
.to_magic
= OPS_MAGIC
;
13591 remote_ops
.to_memory_map
= remote_memory_map
;
13592 remote_ops
.to_flash_erase
= remote_flash_erase
;
13593 remote_ops
.to_flash_done
= remote_flash_done
;
13594 remote_ops
.to_read_description
= remote_read_description
;
13595 remote_ops
.to_search_memory
= remote_search_memory
;
13596 remote_ops
.to_can_async_p
= remote_can_async_p
;
13597 remote_ops
.to_is_async_p
= remote_is_async_p
;
13598 remote_ops
.to_async
= remote_async
;
13599 remote_ops
.to_thread_events
= remote_thread_events
;
13600 remote_ops
.to_can_do_single_step
= remote_can_do_single_step
;
13601 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
13602 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
13603 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
13604 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
13605 remote_ops
.to_supports_disable_randomization
13606 = remote_supports_disable_randomization
;
13607 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
13608 remote_ops
.to_fileio_open
= remote_hostio_open
;
13609 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
13610 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
13611 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
13612 remote_ops
.to_fileio_close
= remote_hostio_close
;
13613 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
13614 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
13615 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
13616 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
13617 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
13618 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
13619 remote_ops
.to_trace_init
= remote_trace_init
;
13620 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
13621 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
13622 remote_ops
.to_download_trace_state_variable
13623 = remote_download_trace_state_variable
;
13624 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
13625 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
13626 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
13627 remote_ops
.to_trace_start
= remote_trace_start
;
13628 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
13629 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
13630 remote_ops
.to_trace_stop
= remote_trace_stop
;
13631 remote_ops
.to_trace_find
= remote_trace_find
;
13632 remote_ops
.to_get_trace_state_variable_value
13633 = remote_get_trace_state_variable_value
;
13634 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
13635 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
13636 remote_ops
.to_upload_trace_state_variables
13637 = remote_upload_trace_state_variables
;
13638 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
13639 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
13640 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
13641 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
13642 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
13643 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
13644 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
13645 remote_ops
.to_verify_memory
= remote_verify_memory
;
13646 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
13647 remote_ops
.to_set_permissions
= remote_set_permissions
;
13648 remote_ops
.to_static_tracepoint_marker_at
13649 = remote_static_tracepoint_marker_at
;
13650 remote_ops
.to_static_tracepoint_markers_by_strid
13651 = remote_static_tracepoint_markers_by_strid
;
13652 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
13653 remote_ops
.to_use_agent
= remote_use_agent
;
13654 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
13655 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
13656 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
13657 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
13658 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
13659 remote_ops
.to_read_btrace
= remote_read_btrace
;
13660 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
13661 remote_ops
.to_augmented_libraries_svr4_read
=
13662 remote_augmented_libraries_svr4_read
;
13663 remote_ops
.to_follow_fork
= remote_follow_fork
;
13664 remote_ops
.to_follow_exec
= remote_follow_exec
;
13665 remote_ops
.to_insert_fork_catchpoint
= remote_insert_fork_catchpoint
;
13666 remote_ops
.to_remove_fork_catchpoint
= remote_remove_fork_catchpoint
;
13667 remote_ops
.to_insert_vfork_catchpoint
= remote_insert_vfork_catchpoint
;
13668 remote_ops
.to_remove_vfork_catchpoint
= remote_remove_vfork_catchpoint
;
13669 remote_ops
.to_insert_exec_catchpoint
= remote_insert_exec_catchpoint
;
13670 remote_ops
.to_remove_exec_catchpoint
= remote_remove_exec_catchpoint
;
13671 remote_ops
.to_execution_direction
= remote_execution_direction
;
13674 /* Set up the extended remote vector by making a copy of the standard
13675 remote vector and adding to it. */
13678 init_extended_remote_ops (void)
13680 extended_remote_ops
= remote_ops
;
13682 extended_remote_ops
.to_shortname
= "extended-remote";
13683 extended_remote_ops
.to_longname
=
13684 "Extended remote serial target in gdb-specific protocol";
13685 extended_remote_ops
.to_doc
=
13686 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13687 Specify the serial device it is connected to (e.g. /dev/ttya).";
13688 extended_remote_ops
.to_open
= extended_remote_open
;
13689 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
13690 extended_remote_ops
.to_detach
= extended_remote_detach
;
13691 extended_remote_ops
.to_attach
= extended_remote_attach
;
13692 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
13693 extended_remote_ops
.to_supports_disable_randomization
13694 = extended_remote_supports_disable_randomization
;
13698 remote_can_async_p (struct target_ops
*ops
)
13700 struct remote_state
*rs
= get_remote_state ();
13702 /* We don't go async if the user has explicitly prevented it with the
13703 "maint set target-async" command. */
13704 if (!target_async_permitted
)
13707 /* We're async whenever the serial device is. */
13708 return serial_can_async_p (rs
->remote_desc
);
13712 remote_is_async_p (struct target_ops
*ops
)
13714 struct remote_state
*rs
= get_remote_state ();
13716 if (!target_async_permitted
)
13717 /* We only enable async when the user specifically asks for it. */
13720 /* We're async whenever the serial device is. */
13721 return serial_is_async_p (rs
->remote_desc
);
13724 /* Pass the SERIAL event on and up to the client. One day this code
13725 will be able to delay notifying the client of an event until the
13726 point where an entire packet has been received. */
13728 static serial_event_ftype remote_async_serial_handler
;
13731 remote_async_serial_handler (struct serial
*scb
, void *context
)
13733 /* Don't propogate error information up to the client. Instead let
13734 the client find out about the error by querying the target. */
13735 inferior_event_handler (INF_REG_EVENT
, NULL
);
13739 remote_async_inferior_event_handler (gdb_client_data data
)
13741 inferior_event_handler (INF_REG_EVENT
, NULL
);
13745 remote_async (struct target_ops
*ops
, int enable
)
13747 struct remote_state
*rs
= get_remote_state ();
13751 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
13753 /* If there are pending events in the stop reply queue tell the
13754 event loop to process them. */
13755 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
13756 mark_async_event_handler (remote_async_inferior_event_token
);
13757 /* For simplicity, below we clear the pending events token
13758 without remembering whether it is marked, so here we always
13759 mark it. If there's actually no pending notification to
13760 process, this ends up being a no-op (other than a spurious
13761 event-loop wakeup). */
13762 if (target_is_non_stop_p ())
13763 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13767 serial_async (rs
->remote_desc
, NULL
, NULL
);
13768 /* If the core is disabling async, it doesn't want to be
13769 disturbed with target events. Clear all async event sources
13771 clear_async_event_handler (remote_async_inferior_event_token
);
13772 if (target_is_non_stop_p ())
13773 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13777 /* Implementation of the to_thread_events method. */
13780 remote_thread_events (struct target_ops
*ops
, int enable
)
13782 struct remote_state
*rs
= get_remote_state ();
13783 size_t size
= get_remote_packet_size ();
13785 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
13788 xsnprintf (rs
->buf
, size
, "QThreadEvents:%x", enable
? 1 : 0);
13790 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13792 switch (packet_ok (rs
->buf
,
13793 &remote_protocol_packets
[PACKET_QThreadEvents
]))
13796 if (strcmp (rs
->buf
, "OK") != 0)
13797 error (_("Remote refused setting thread events: %s"), rs
->buf
);
13800 warning (_("Remote failure reply: %s"), rs
->buf
);
13802 case PACKET_UNKNOWN
:
13808 set_remote_cmd (char *args
, int from_tty
)
13810 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
13814 show_remote_cmd (char *args
, int from_tty
)
13816 /* We can't just use cmd_show_list here, because we want to skip
13817 the redundant "show remote Z-packet" and the legacy aliases. */
13818 struct cmd_list_element
*list
= remote_show_cmdlist
;
13819 struct ui_out
*uiout
= current_uiout
;
13821 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
13822 for (; list
!= NULL
; list
= list
->next
)
13823 if (strcmp (list
->name
, "Z-packet") == 0)
13825 else if (list
->type
== not_set_cmd
)
13826 /* Alias commands are exactly like the original, except they
13827 don't have the normal type. */
13831 ui_out_emit_tuple
option_emitter (uiout
, "option");
13833 uiout
->field_string ("name", list
->name
);
13834 uiout
->text (": ");
13835 if (list
->type
== show_cmd
)
13836 do_show_command (NULL
, from_tty
, list
);
13838 cmd_func (list
, NULL
, from_tty
);
13843 /* Function to be called whenever a new objfile (shlib) is detected. */
13845 remote_new_objfile (struct objfile
*objfile
)
13847 struct remote_state
*rs
= get_remote_state ();
13849 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
13850 remote_check_symbols ();
13853 /* Pull all the tracepoints defined on the target and create local
13854 data structures representing them. We don't want to create real
13855 tracepoints yet, we don't want to mess up the user's existing
13859 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
13861 struct remote_state
*rs
= get_remote_state ();
13864 /* Ask for a first packet of tracepoint definition. */
13866 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13868 while (*p
&& *p
!= 'l')
13870 parse_tracepoint_definition (p
, utpp
);
13871 /* Ask for another packet of tracepoint definition. */
13873 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13880 remote_upload_trace_state_variables (struct target_ops
*self
,
13881 struct uploaded_tsv
**utsvp
)
13883 struct remote_state
*rs
= get_remote_state ();
13886 /* Ask for a first packet of variable definition. */
13888 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13890 while (*p
&& *p
!= 'l')
13892 parse_tsv_definition (p
, utsvp
);
13893 /* Ask for another packet of variable definition. */
13895 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13901 /* The "set/show range-stepping" show hook. */
13904 show_range_stepping (struct ui_file
*file
, int from_tty
,
13905 struct cmd_list_element
*c
,
13908 fprintf_filtered (file
,
13909 _("Debugger's willingness to use range stepping "
13910 "is %s.\n"), value
);
13913 /* The "set/show range-stepping" set hook. */
13916 set_range_stepping (char *ignore_args
, int from_tty
,
13917 struct cmd_list_element
*c
)
13919 struct remote_state
*rs
= get_remote_state ();
13921 /* Whene enabling, check whether range stepping is actually
13922 supported by the target, and warn if not. */
13923 if (use_range_stepping
)
13925 if (rs
->remote_desc
!= NULL
)
13927 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13928 remote_vcont_probe (rs
);
13930 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
13931 && rs
->supports_vCont
.r
)
13935 warning (_("Range stepping is not supported by the current target"));
13940 _initialize_remote (void)
13942 struct cmd_list_element
*cmd
;
13943 const char *cmd_name
;
13945 /* architecture specific data */
13946 remote_gdbarch_data_handle
=
13947 gdbarch_data_register_post_init (init_remote_state
);
13948 remote_g_packet_data_handle
=
13949 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
13952 = register_program_space_data_with_cleanup (NULL
,
13953 remote_pspace_data_cleanup
);
13955 /* Initialize the per-target state. At the moment there is only one
13956 of these, not one per target. Only one target is active at a
13958 remote_state
= new_remote_state ();
13960 init_remote_ops ();
13961 add_target (&remote_ops
);
13963 init_extended_remote_ops ();
13964 add_target (&extended_remote_ops
);
13966 /* Hook into new objfile notification. */
13967 observer_attach_new_objfile (remote_new_objfile
);
13968 /* We're no longer interested in notification events of an inferior
13970 observer_attach_inferior_exit (discard_pending_stop_replies
);
13973 init_remote_threadtests ();
13976 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
13977 /* set/show remote ... */
13979 add_prefix_cmd ("remote", class_maintenance
, set_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_set_cmdlist
, "set remote ",
13984 0 /* allow-unknown */, &setlist
);
13985 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
13986 Remote protocol specific variables\n\
13987 Configure various remote-protocol specific variables such as\n\
13988 the packets being used"),
13989 &remote_show_cmdlist
, "show remote ",
13990 0 /* allow-unknown */, &showlist
);
13992 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
13993 Compare section data on target to the exec file.\n\
13994 Argument is a single section name (default: all loaded sections).\n\
13995 To compare only read-only loaded sections, specify the -r option."),
13998 add_cmd ("packet", class_maintenance
, packet_command
, _("\
13999 Send an arbitrary packet to a remote target.\n\
14000 maintenance packet TEXT\n\
14001 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14002 this command sends the string TEXT to the inferior, and displays the\n\
14003 response packet. GDB supplies the initial `$' character, and the\n\
14004 terminating `#' character and checksum."),
14007 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14008 Set whether to send break if interrupted."), _("\
14009 Show whether to send break if interrupted."), _("\
14010 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14011 set_remotebreak
, show_remotebreak
,
14012 &setlist
, &showlist
);
14013 cmd_name
= "remotebreak";
14014 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14015 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14016 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14017 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14018 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14020 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14021 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14023 Set interrupt sequence to remote target."), _("\
14024 Show interrupt sequence to remote target."), _("\
14025 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14026 NULL
, show_interrupt_sequence
,
14027 &remote_set_cmdlist
,
14028 &remote_show_cmdlist
);
14030 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14031 &interrupt_on_connect
, _("\
14032 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14033 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14034 If set, interrupt sequence is sent to remote target."),
14036 &remote_set_cmdlist
, &remote_show_cmdlist
);
14038 /* Install commands for configuring memory read/write packets. */
14040 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14041 Set the maximum number of bytes per memory write packet (deprecated)."),
14043 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14044 Show the maximum number of bytes per memory write packet (deprecated)."),
14046 add_cmd ("memory-write-packet-size", no_class
,
14047 set_memory_write_packet_size
, _("\
14048 Set the maximum number of bytes per memory-write packet.\n\
14049 Specify the number of bytes in a packet or 0 (zero) for the\n\
14050 default packet size. The actual limit is further reduced\n\
14051 dependent on the target. Specify ``fixed'' to disable the\n\
14052 further restriction and ``limit'' to enable that restriction."),
14053 &remote_set_cmdlist
);
14054 add_cmd ("memory-read-packet-size", no_class
,
14055 set_memory_read_packet_size
, _("\
14056 Set the maximum number of bytes per memory-read packet.\n\
14057 Specify the number of bytes in a packet or 0 (zero) for the\n\
14058 default packet size. The actual limit is further reduced\n\
14059 dependent on the target. Specify ``fixed'' to disable the\n\
14060 further restriction and ``limit'' to enable that restriction."),
14061 &remote_set_cmdlist
);
14062 add_cmd ("memory-write-packet-size", no_class
,
14063 show_memory_write_packet_size
,
14064 _("Show the maximum number of bytes per memory-write packet."),
14065 &remote_show_cmdlist
);
14066 add_cmd ("memory-read-packet-size", no_class
,
14067 show_memory_read_packet_size
,
14068 _("Show the maximum number of bytes per memory-read packet."),
14069 &remote_show_cmdlist
);
14071 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
14072 &remote_hw_watchpoint_limit
, _("\
14073 Set the maximum number of target hardware watchpoints."), _("\
14074 Show the maximum number of target hardware watchpoints."), _("\
14075 Specify a negative limit for unlimited."),
14076 NULL
, NULL
, /* FIXME: i18n: The maximum
14077 number of target hardware
14078 watchpoints is %s. */
14079 &remote_set_cmdlist
, &remote_show_cmdlist
);
14080 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
14081 &remote_hw_watchpoint_length_limit
, _("\
14082 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14083 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14084 Specify a negative limit for unlimited."),
14085 NULL
, NULL
, /* FIXME: i18n: The maximum
14086 length (in bytes) of a target
14087 hardware watchpoint is %s. */
14088 &remote_set_cmdlist
, &remote_show_cmdlist
);
14089 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
14090 &remote_hw_breakpoint_limit
, _("\
14091 Set the maximum number of target hardware breakpoints."), _("\
14092 Show the maximum number of target hardware breakpoints."), _("\
14093 Specify a negative limit for unlimited."),
14094 NULL
, NULL
, /* FIXME: i18n: The maximum
14095 number of target hardware
14096 breakpoints is %s. */
14097 &remote_set_cmdlist
, &remote_show_cmdlist
);
14099 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14100 &remote_address_size
, _("\
14101 Set the maximum size of the address (in bits) in a memory packet."), _("\
14102 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14104 NULL
, /* FIXME: i18n: */
14105 &setlist
, &showlist
);
14107 init_all_packet_configs ();
14109 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14110 "X", "binary-download", 1);
14112 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14113 "vCont", "verbose-resume", 0);
14115 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14116 "QPassSignals", "pass-signals", 0);
14118 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14119 "QCatchSyscalls", "catch-syscalls", 0);
14121 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14122 "QProgramSignals", "program-signals", 0);
14124 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14125 "QStartupWithShell", "startup-with-shell", 0);
14127 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14128 "qSymbol", "symbol-lookup", 0);
14130 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14131 "P", "set-register", 1);
14133 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14134 "p", "fetch-register", 1);
14136 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14137 "Z0", "software-breakpoint", 0);
14139 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14140 "Z1", "hardware-breakpoint", 0);
14142 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14143 "Z2", "write-watchpoint", 0);
14145 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14146 "Z3", "read-watchpoint", 0);
14148 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14149 "Z4", "access-watchpoint", 0);
14151 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14152 "qXfer:auxv:read", "read-aux-vector", 0);
14154 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14155 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14157 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14158 "qXfer:features:read", "target-features", 0);
14160 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14161 "qXfer:libraries:read", "library-info", 0);
14163 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14164 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14166 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14167 "qXfer:memory-map:read", "memory-map", 0);
14169 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14170 "qXfer:spu:read", "read-spu-object", 0);
14172 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14173 "qXfer:spu:write", "write-spu-object", 0);
14175 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14176 "qXfer:osdata:read", "osdata", 0);
14178 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14179 "qXfer:threads:read", "threads", 0);
14181 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14182 "qXfer:siginfo:read", "read-siginfo-object", 0);
14184 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14185 "qXfer:siginfo:write", "write-siginfo-object", 0);
14187 add_packet_config_cmd
14188 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14189 "qXfer:traceframe-info:read", "traceframe-info", 0);
14191 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14192 "qXfer:uib:read", "unwind-info-block", 0);
14194 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14195 "qGetTLSAddr", "get-thread-local-storage-address",
14198 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14199 "qGetTIBAddr", "get-thread-information-block-address",
14202 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14203 "bc", "reverse-continue", 0);
14205 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14206 "bs", "reverse-step", 0);
14208 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14209 "qSupported", "supported-packets", 0);
14211 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14212 "qSearch:memory", "search-memory", 0);
14214 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14215 "qTStatus", "trace-status", 0);
14217 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14218 "vFile:setfs", "hostio-setfs", 0);
14220 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14221 "vFile:open", "hostio-open", 0);
14223 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14224 "vFile:pread", "hostio-pread", 0);
14226 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14227 "vFile:pwrite", "hostio-pwrite", 0);
14229 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14230 "vFile:close", "hostio-close", 0);
14232 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14233 "vFile:unlink", "hostio-unlink", 0);
14235 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14236 "vFile:readlink", "hostio-readlink", 0);
14238 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14239 "vFile:fstat", "hostio-fstat", 0);
14241 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14242 "vAttach", "attach", 0);
14244 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14247 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14248 "QStartNoAckMode", "noack", 0);
14250 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14251 "vKill", "kill", 0);
14253 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14254 "qAttached", "query-attached", 0);
14256 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14257 "ConditionalTracepoints",
14258 "conditional-tracepoints", 0);
14260 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14261 "ConditionalBreakpoints",
14262 "conditional-breakpoints", 0);
14264 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14265 "BreakpointCommands",
14266 "breakpoint-commands", 0);
14268 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14269 "FastTracepoints", "fast-tracepoints", 0);
14271 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14272 "TracepointSource", "TracepointSource", 0);
14274 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14275 "QAllow", "allow", 0);
14277 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14278 "StaticTracepoints", "static-tracepoints", 0);
14280 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14281 "InstallInTrace", "install-in-trace", 0);
14283 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14284 "qXfer:statictrace:read", "read-sdata-object", 0);
14286 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14287 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14289 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14290 "QDisableRandomization", "disable-randomization", 0);
14292 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14293 "QAgent", "agent", 0);
14295 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14296 "QTBuffer:size", "trace-buffer-size", 0);
14298 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14299 "Qbtrace:off", "disable-btrace", 0);
14301 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14302 "Qbtrace:bts", "enable-btrace-bts", 0);
14304 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14305 "Qbtrace:pt", "enable-btrace-pt", 0);
14307 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14308 "qXfer:btrace", "read-btrace", 0);
14310 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14311 "qXfer:btrace-conf", "read-btrace-conf", 0);
14313 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14314 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14316 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14317 "multiprocess-feature", "multiprocess-feature", 0);
14319 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14320 "swbreak-feature", "swbreak-feature", 0);
14322 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14323 "hwbreak-feature", "hwbreak-feature", 0);
14325 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14326 "fork-event-feature", "fork-event-feature", 0);
14328 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14329 "vfork-event-feature", "vfork-event-feature", 0);
14331 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14332 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14334 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14335 "vContSupported", "verbose-resume-supported", 0);
14337 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14338 "exec-event-feature", "exec-event-feature", 0);
14340 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14341 "vCtrlC", "ctrl-c", 0);
14343 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14344 "QThreadEvents", "thread-events", 0);
14346 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14347 "N stop reply", "no-resumed-stop-reply", 0);
14349 /* Assert that we've registered "set remote foo-packet" commands
14350 for all packet configs. */
14354 for (i
= 0; i
< PACKET_MAX
; i
++)
14356 /* Ideally all configs would have a command associated. Some
14357 still don't though. */
14362 case PACKET_QNonStop
:
14363 case PACKET_EnableDisableTracepoints_feature
:
14364 case PACKET_tracenz_feature
:
14365 case PACKET_DisconnectedTracing_feature
:
14366 case PACKET_augmented_libraries_svr4_read_feature
:
14368 /* Additions to this list need to be well justified:
14369 pre-existing packets are OK; new packets are not. */
14377 /* This catches both forgetting to add a config command, and
14378 forgetting to remove a packet from the exception list. */
14379 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14383 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14384 Z sub-packet has its own set and show commands, but users may
14385 have sets to this variable in their .gdbinit files (or in their
14387 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14388 &remote_Z_packet_detect
, _("\
14389 Set use of remote protocol `Z' packets"), _("\
14390 Show use of remote protocol `Z' packets "), _("\
14391 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14393 set_remote_protocol_Z_packet_cmd
,
14394 show_remote_protocol_Z_packet_cmd
,
14395 /* FIXME: i18n: Use of remote protocol
14396 `Z' packets is %s. */
14397 &remote_set_cmdlist
, &remote_show_cmdlist
);
14399 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14400 Manipulate files on the remote system\n\
14401 Transfer files to and from the remote target system."),
14402 &remote_cmdlist
, "remote ",
14403 0 /* allow-unknown */, &cmdlist
);
14405 add_cmd ("put", class_files
, remote_put_command
,
14406 _("Copy a local file to the remote system."),
14409 add_cmd ("get", class_files
, remote_get_command
,
14410 _("Copy a remote file to the local system."),
14413 add_cmd ("delete", class_files
, remote_delete_command
,
14414 _("Delete a remote file."),
14417 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14418 &remote_exec_file_var
, _("\
14419 Set the remote pathname for \"run\""), _("\
14420 Show the remote pathname for \"run\""), NULL
,
14421 set_remote_exec_file
,
14422 show_remote_exec_file
,
14423 &remote_set_cmdlist
,
14424 &remote_show_cmdlist
);
14426 add_setshow_boolean_cmd ("range-stepping", class_run
,
14427 &use_range_stepping
, _("\
14428 Enable or disable range stepping."), _("\
14429 Show whether target-assisted range stepping is enabled."), _("\
14430 If on, and the target supports it, when stepping a source line, GDB\n\
14431 tells the target to step the corresponding range of addresses itself instead\n\
14432 of issuing multiple single-steps. This speeds up source level\n\
14433 stepping. If off, GDB always issues single-steps, even if range\n\
14434 stepping is supported by the target. The default is on."),
14435 set_range_stepping
,
14436 show_range_stepping
,
14440 /* Eventually initialize fileio. See fileio.c */
14441 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
14443 /* Take advantage of the fact that the TID field is not used, to tag
14444 special ptids with it set to != 0. */
14445 magic_null_ptid
= ptid_build (42000, -1, 1);
14446 not_sent_ptid
= ptid_build (42000, -2, 1);
14447 any_thread_ptid
= ptid_build (42000, 0, 1);
14449 target_buf_size
= 2048;
14450 target_buf
= (char *) xmalloc (target_buf_size
);