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 (struct ptid ptid
);
145 static void set_continue_thread (struct ptid 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 /* Data for the vFile:pread readahead cache. */
288 struct readahead_cache
290 /* The file descriptor for the file that is being cached. -1 if the
294 /* The offset into the file that the cache buffer corresponds
298 /* The buffer holding the cache contents. */
300 /* The buffer's size. We try to read as much as fits into a packet
304 /* Cache hit and miss counters. */
309 /* Description of the remote protocol state for the currently
310 connected target. This is per-target state, and independent of the
311 selected architecture. */
315 /* A buffer to use for incoming packets, and its current size. The
316 buffer is grown dynamically for larger incoming packets.
317 Outgoing packets may also be constructed in this buffer.
318 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
319 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
324 /* True if we're going through initial connection setup (finding out
325 about the remote side's threads, relocating symbols, etc.). */
328 /* If we negotiated packet size explicitly (and thus can bypass
329 heuristics for the largest packet size that will not overflow
330 a buffer in the stub), this will be set to that packet size.
331 Otherwise zero, meaning to use the guessed size. */
332 long explicit_packet_size
;
334 /* remote_wait is normally called when the target is running and
335 waits for a stop reply packet. But sometimes we need to call it
336 when the target is already stopped. We can send a "?" packet
337 and have remote_wait read the response. Or, if we already have
338 the response, we can stash it in BUF and tell remote_wait to
339 skip calling getpkt. This flag is set when BUF contains a
340 stop reply packet and the target is not waiting. */
341 int cached_wait_status
;
343 /* True, if in no ack mode. That is, neither GDB nor the stub will
344 expect acks from each other. The connection is assumed to be
348 /* True if we're connected in extended remote mode. */
351 /* True if we resumed the target and we're waiting for the target to
352 stop. In the mean time, we can't start another command/query.
353 The remote server wouldn't be ready to process it, so we'd
354 timeout waiting for a reply that would never come and eventually
355 we'd close the connection. This can happen in asynchronous mode
356 because we allow GDB commands while the target is running. */
357 int waiting_for_stop_reply
;
359 /* The status of the stub support for the various vCont actions. */
360 struct vCont_action_support supports_vCont
;
362 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
363 responded to that. */
366 /* True if we saw a Ctrl-C while reading or writing from/to the
367 remote descriptor. At that point it is not safe to send a remote
368 interrupt packet, so we instead remember we saw the Ctrl-C and
369 process it once we're done with sending/receiving the current
370 packet, which should be shortly. If however that takes too long,
371 and the user presses Ctrl-C again, we offer to disconnect. */
372 int got_ctrlc_during_io
;
374 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
375 remote_open knows that we don't have a file open when the program
377 struct serial
*remote_desc
;
379 /* These are the threads which we last sent to the remote system. The
380 TID member will be -1 for all or -2 for not sent yet. */
381 ptid_t general_thread
;
382 ptid_t continue_thread
;
384 /* This is the traceframe which we last selected on the remote system.
385 It will be -1 if no traceframe is selected. */
386 int remote_traceframe_number
;
388 char *last_pass_packet
;
390 /* The last QProgramSignals packet sent to the target. We bypass
391 sending a new program signals list down to the target if the new
392 packet is exactly the same as the last we sent. IOW, we only let
393 the target know about program signals list changes. */
394 char *last_program_signals_packet
;
396 enum gdb_signal last_sent_signal
;
400 /* The execution direction of the last resume we got. */
401 enum exec_direction_kind last_resume_exec_dir
;
403 char *finished_object
;
404 char *finished_annex
;
405 ULONGEST finished_offset
;
407 /* Should we try the 'ThreadInfo' query packet?
409 This variable (NOT available to the user: auto-detect only!)
410 determines whether GDB will use the new, simpler "ThreadInfo"
411 query or the older, more complex syntax for thread queries.
412 This is an auto-detect variable (set to true at each connect,
413 and set to false when the target fails to recognize it). */
414 int use_threadinfo_query
;
415 int use_threadextra_query
;
417 threadref echo_nextthread
;
418 threadref nextthread
;
419 threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
421 /* The state of remote notification. */
422 struct remote_notif_state
*notif_state
;
424 /* The branch trace configuration. */
425 struct btrace_config btrace_config
;
427 /* The argument to the last "vFile:setfs:" packet we sent, used
428 to avoid sending repeated unnecessary "vFile:setfs:" packets.
429 Initialized to -1 to indicate that no "vFile:setfs:" packet
430 has yet been sent. */
433 /* A readahead cache for vFile:pread. Often, reading a binary
434 involves a sequence of small reads. E.g., when parsing an ELF
435 file. A readahead cache helps mostly the case of remote
436 debugging on a connection with higher latency, due to the
437 request/reply nature of the RSP. We only cache data for a single
438 file descriptor at a time. */
439 struct readahead_cache readahead_cache
;
442 /* Private data that we'll store in (struct thread_info)->private. */
443 struct private_thread_info
449 /* Whether the target stopped for a breakpoint/watchpoint. */
450 enum target_stop_reason stop_reason
;
452 /* This is set to the data address of the access causing the target
453 to stop for a watchpoint. */
454 CORE_ADDR watch_data_address
;
456 /* Fields used by the vCont action coalescing implemented in
457 remote_resume / remote_commit_resume. remote_resume stores each
458 thread's last resume request in these fields, so that a later
459 remote_commit_resume knows which is the proper action for this
460 thread to include in the vCont packet. */
462 /* True if the last target_resume call for this thread was a step
463 request, false if a continue request. */
464 int last_resume_step
;
466 /* The signal specified in the last target_resume call for this
468 enum gdb_signal last_resume_sig
;
470 /* Whether this thread was already vCont-resumed on the remote
476 free_private_thread_info (struct private_thread_info
*info
)
483 /* This data could be associated with a target, but we do not always
484 have access to the current target when we need it, so for now it is
485 static. This will be fine for as long as only one target is in use
487 static struct remote_state
*remote_state
;
489 static struct remote_state
*
490 get_remote_state_raw (void)
495 /* Allocate a new struct remote_state with xmalloc, initialize it, and
498 static struct remote_state
*
499 new_remote_state (void)
501 struct remote_state
*result
= XCNEW (struct remote_state
);
503 /* The default buffer size is unimportant; it will be expanded
504 whenever a larger buffer is needed. */
505 result
->buf_size
= 400;
506 result
->buf
= (char *) xmalloc (result
->buf_size
);
507 result
->remote_traceframe_number
= -1;
508 result
->last_sent_signal
= GDB_SIGNAL_0
;
509 result
->last_resume_exec_dir
= EXEC_FORWARD
;
515 /* Description of the remote protocol for a given architecture. */
519 long offset
; /* Offset into G packet. */
520 long regnum
; /* GDB's internal register number. */
521 LONGEST pnum
; /* Remote protocol register number. */
522 int in_g_packet
; /* Always part of G packet. */
523 /* long size in bytes; == register_size (target_gdbarch (), regnum);
525 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
529 struct remote_arch_state
531 /* Description of the remote protocol registers. */
532 long sizeof_g_packet
;
534 /* Description of the remote protocol registers indexed by REGNUM
535 (making an array gdbarch_num_regs in size). */
536 struct packet_reg
*regs
;
538 /* This is the size (in chars) of the first response to the ``g''
539 packet. It is used as a heuristic when determining the maximum
540 size of memory-read and memory-write packets. A target will
541 typically only reserve a buffer large enough to hold the ``g''
542 packet. The size does not include packet overhead (headers and
544 long actual_register_packet_size
;
546 /* This is the maximum size (in chars) of a non read/write packet.
547 It is also used as a cap on the size of read/write packets. */
548 long remote_packet_size
;
551 /* Utility: generate error from an incoming stub packet. */
553 trace_error (char *buf
)
556 return; /* not an error msg */
559 case '1': /* malformed packet error */
560 if (*++buf
== '0') /* general case: */
561 error (_("remote.c: error in outgoing packet."));
563 error (_("remote.c: error in outgoing packet at field #%ld."),
564 strtol (buf
, NULL
, 16));
566 error (_("Target returns error code '%s'."), buf
);
570 /* Utility: wait for reply from stub, while accepting "O" packets. */
572 remote_get_noisy_reply (char **buf_p
,
575 do /* Loop on reply from remote stub. */
579 QUIT
; /* Allow user to bail out with ^C. */
580 getpkt (buf_p
, sizeof_buf
, 0);
584 else if (startswith (buf
, "qRelocInsn:"))
587 CORE_ADDR from
, to
, org_to
;
589 int adjusted_size
= 0;
592 p
= buf
+ strlen ("qRelocInsn:");
593 pp
= unpack_varlen_hex (p
, &ul
);
595 error (_("invalid qRelocInsn packet: %s"), buf
);
599 unpack_varlen_hex (p
, &ul
);
606 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
609 CATCH (ex
, RETURN_MASK_ALL
)
611 if (ex
.error
== MEMORY_ERROR
)
613 /* Propagate memory errors silently back to the
614 target. The stub may have limited the range of
615 addresses we can write to, for example. */
619 /* Something unexpectedly bad happened. Be verbose
620 so we can tell what, and propagate the error back
621 to the stub, so it doesn't get stuck waiting for
623 exception_fprintf (gdb_stderr
, ex
,
624 _("warning: relocating instruction: "));
632 adjusted_size
= to
- org_to
;
634 xsnprintf (buf
, *sizeof_buf
, "qRelocInsn:%x", adjusted_size
);
638 else if (buf
[0] == 'O' && buf
[1] != 'K')
639 remote_console_output (buf
+ 1); /* 'O' message from stub */
641 return buf
; /* Here's the actual reply. */
646 /* Handle for retreving the remote protocol data from gdbarch. */
647 static struct gdbarch_data
*remote_gdbarch_data_handle
;
649 static struct remote_arch_state
*
650 get_remote_arch_state (void)
652 gdb_assert (target_gdbarch () != NULL
);
653 return ((struct remote_arch_state
*)
654 gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle
));
657 /* Fetch the global remote target state. */
659 static struct remote_state
*
660 get_remote_state (void)
662 /* Make sure that the remote architecture state has been
663 initialized, because doing so might reallocate rs->buf. Any
664 function which calls getpkt also needs to be mindful of changes
665 to rs->buf, but this call limits the number of places which run
667 get_remote_arch_state ();
669 return get_remote_state_raw ();
672 /* Cleanup routine for the remote module's pspace data. */
675 remote_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
677 char *remote_exec_file
= (char *) arg
;
679 xfree (remote_exec_file
);
682 /* Fetch the remote exec-file from the current program space. */
685 get_remote_exec_file (void)
687 char *remote_exec_file
;
690 = (char *) program_space_data (current_program_space
,
692 if (remote_exec_file
== NULL
)
695 return remote_exec_file
;
698 /* Set the remote exec file for PSPACE. */
701 set_pspace_remote_exec_file (struct program_space
*pspace
,
702 char *remote_exec_file
)
704 char *old_file
= (char *) program_space_data (pspace
, remote_pspace_data
);
707 set_program_space_data (pspace
, remote_pspace_data
,
708 xstrdup (remote_exec_file
));
711 /* The "set/show remote exec-file" set command hook. */
714 set_remote_exec_file (char *ignored
, int from_tty
,
715 struct cmd_list_element
*c
)
717 gdb_assert (remote_exec_file_var
!= NULL
);
718 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
721 /* The "set/show remote exec-file" show command hook. */
724 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
725 struct cmd_list_element
*cmd
, const char *value
)
727 fprintf_filtered (file
, "%s\n", remote_exec_file_var
);
731 compare_pnums (const void *lhs_
, const void *rhs_
)
733 const struct packet_reg
* const *lhs
734 = (const struct packet_reg
* const *) lhs_
;
735 const struct packet_reg
* const *rhs
736 = (const struct packet_reg
* const *) rhs_
;
738 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
740 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
747 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
749 int regnum
, num_remote_regs
, offset
;
750 struct packet_reg
**remote_regs
;
752 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
754 struct packet_reg
*r
= ®s
[regnum
];
756 if (register_size (gdbarch
, regnum
) == 0)
757 /* Do not try to fetch zero-sized (placeholder) registers. */
760 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
765 /* Define the g/G packet format as the contents of each register
766 with a remote protocol number, in order of ascending protocol
769 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
770 for (num_remote_regs
= 0, regnum
= 0;
771 regnum
< gdbarch_num_regs (gdbarch
);
773 if (regs
[regnum
].pnum
!= -1)
774 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
776 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
779 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
781 remote_regs
[regnum
]->in_g_packet
= 1;
782 remote_regs
[regnum
]->offset
= offset
;
783 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
789 /* Given the architecture described by GDBARCH, return the remote
790 protocol register's number and the register's offset in the g/G
791 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
792 If the target does not have a mapping for REGNUM, return false,
793 otherwise, return true. */
796 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
797 int *pnum
, int *poffset
)
799 struct packet_reg
*regs
;
800 struct cleanup
*old_chain
;
802 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
804 regs
= XCNEWVEC (struct packet_reg
, gdbarch_num_regs (gdbarch
));
805 old_chain
= make_cleanup (xfree
, regs
);
807 map_regcache_remote_table (gdbarch
, regs
);
809 *pnum
= regs
[regnum
].pnum
;
810 *poffset
= regs
[regnum
].offset
;
812 do_cleanups (old_chain
);
818 init_remote_state (struct gdbarch
*gdbarch
)
820 struct remote_state
*rs
= get_remote_state_raw ();
821 struct remote_arch_state
*rsa
;
823 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
825 /* Use the architecture to build a regnum<->pnum table, which will be
826 1:1 unless a feature set specifies otherwise. */
827 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
828 gdbarch_num_regs (gdbarch
),
831 /* Record the maximum possible size of the g packet - it may turn out
833 rsa
->sizeof_g_packet
= map_regcache_remote_table (gdbarch
, rsa
->regs
);
835 /* Default maximum number of characters in a packet body. Many
836 remote stubs have a hardwired buffer size of 400 bytes
837 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
838 as the maximum packet-size to ensure that the packet and an extra
839 NUL character can always fit in the buffer. This stops GDB
840 trashing stubs that try to squeeze an extra NUL into what is
841 already a full buffer (As of 1999-12-04 that was most stubs). */
842 rsa
->remote_packet_size
= 400 - 1;
844 /* This one is filled in when a ``g'' packet is received. */
845 rsa
->actual_register_packet_size
= 0;
847 /* Should rsa->sizeof_g_packet needs more space than the
848 default, adjust the size accordingly. Remember that each byte is
849 encoded as two characters. 32 is the overhead for the packet
850 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
851 (``$NN:G...#NN'') is a better guess, the below has been padded a
853 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
854 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
856 /* Make sure that the packet buffer is plenty big enough for
857 this architecture. */
858 if (rs
->buf_size
< rsa
->remote_packet_size
)
860 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
861 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
867 /* Return the current allowed size of a remote packet. This is
868 inferred from the current architecture, and should be used to
869 limit the length of outgoing packets. */
871 get_remote_packet_size (void)
873 struct remote_state
*rs
= get_remote_state ();
874 struct remote_arch_state
*rsa
= get_remote_arch_state ();
876 if (rs
->explicit_packet_size
)
877 return rs
->explicit_packet_size
;
879 return rsa
->remote_packet_size
;
882 static struct packet_reg
*
883 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
885 if (regnum
< 0 && regnum
>= gdbarch_num_regs (target_gdbarch ()))
889 struct packet_reg
*r
= &rsa
->regs
[regnum
];
891 gdb_assert (r
->regnum
== regnum
);
896 static struct packet_reg
*
897 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
901 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
903 struct packet_reg
*r
= &rsa
->regs
[i
];
911 static struct target_ops remote_ops
;
913 static struct target_ops extended_remote_ops
;
915 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
916 ``forever'' still use the normal timeout mechanism. This is
917 currently used by the ASYNC code to guarentee that target reads
918 during the initial connect always time-out. Once getpkt has been
919 modified to return a timeout indication and, in turn
920 remote_wait()/wait_for_inferior() have gained a timeout parameter
922 static int wait_forever_enabled_p
= 1;
924 /* Allow the user to specify what sequence to send to the remote
925 when he requests a program interruption: Although ^C is usually
926 what remote systems expect (this is the default, here), it is
927 sometimes preferable to send a break. On other systems such
928 as the Linux kernel, a break followed by g, which is Magic SysRq g
929 is required in order to interrupt the execution. */
930 const char interrupt_sequence_control_c
[] = "Ctrl-C";
931 const char interrupt_sequence_break
[] = "BREAK";
932 const char interrupt_sequence_break_g
[] = "BREAK-g";
933 static const char *const interrupt_sequence_modes
[] =
935 interrupt_sequence_control_c
,
936 interrupt_sequence_break
,
937 interrupt_sequence_break_g
,
940 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
943 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
944 struct cmd_list_element
*c
,
947 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
948 fprintf_filtered (file
,
949 _("Send the ASCII ETX character (Ctrl-c) "
950 "to the remote target to interrupt the "
951 "execution of the program.\n"));
952 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
953 fprintf_filtered (file
,
954 _("send a break signal to the remote target "
955 "to interrupt the execution of the program.\n"));
956 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
957 fprintf_filtered (file
,
958 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
959 "the remote target to interrupt the execution "
960 "of Linux kernel.\n"));
962 internal_error (__FILE__
, __LINE__
,
963 _("Invalid value for interrupt_sequence_mode: %s."),
964 interrupt_sequence_mode
);
967 /* This boolean variable specifies whether interrupt_sequence is sent
968 to the remote target when gdb connects to it.
969 This is mostly needed when you debug the Linux kernel: The Linux kernel
970 expects BREAK g which is Magic SysRq g for connecting gdb. */
971 static int interrupt_on_connect
= 0;
973 /* This variable is used to implement the "set/show remotebreak" commands.
974 Since these commands are now deprecated in favor of "set/show remote
975 interrupt-sequence", it no longer has any effect on the code. */
976 static int remote_break
;
979 set_remotebreak (char *args
, int from_tty
, struct cmd_list_element
*c
)
982 interrupt_sequence_mode
= interrupt_sequence_break
;
984 interrupt_sequence_mode
= interrupt_sequence_control_c
;
988 show_remotebreak (struct ui_file
*file
, int from_tty
,
989 struct cmd_list_element
*c
,
994 /* This variable sets the number of bits in an address that are to be
995 sent in a memory ("M" or "m") packet. Normally, after stripping
996 leading zeros, the entire address would be sent. This variable
997 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
998 initial implementation of remote.c restricted the address sent in
999 memory packets to ``host::sizeof long'' bytes - (typically 32
1000 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1001 address was never sent. Since fixing this bug may cause a break in
1002 some remote targets this variable is principly provided to
1003 facilitate backward compatibility. */
1005 static unsigned int remote_address_size
;
1007 /* Temporary to track who currently owns the terminal. See
1008 remote_terminal_* for more details. */
1010 static int remote_async_terminal_ours_p
;
1013 /* User configurable variables for the number of characters in a
1014 memory read/write packet. MIN (rsa->remote_packet_size,
1015 rsa->sizeof_g_packet) is the default. Some targets need smaller
1016 values (fifo overruns, et.al.) and some users need larger values
1017 (speed up transfers). The variables ``preferred_*'' (the user
1018 request), ``current_*'' (what was actually set) and ``forced_*''
1019 (Positive - a soft limit, negative - a hard limit). */
1021 struct memory_packet_config
1028 /* The default max memory-write-packet-size. The 16k is historical.
1029 (It came from older GDB's using alloca for buffers and the
1030 knowledge (folklore?) that some hosts don't cope very well with
1031 large alloca calls.) */
1032 #define DEFAULT_MAX_MEMORY_PACKET_SIZE 16384
1034 /* The minimum remote packet size for memory transfers. Ensures we
1035 can write at least one byte. */
1036 #define MIN_MEMORY_PACKET_SIZE 20
1038 /* Compute the current size of a read/write packet. Since this makes
1039 use of ``actual_register_packet_size'' the computation is dynamic. */
1042 get_memory_packet_size (struct memory_packet_config
*config
)
1044 struct remote_state
*rs
= get_remote_state ();
1045 struct remote_arch_state
*rsa
= get_remote_arch_state ();
1048 if (config
->fixed_p
)
1050 if (config
->size
<= 0)
1051 what_they_get
= DEFAULT_MAX_MEMORY_PACKET_SIZE
;
1053 what_they_get
= config
->size
;
1057 what_they_get
= get_remote_packet_size ();
1058 /* Limit the packet to the size specified by the user. */
1059 if (config
->size
> 0
1060 && what_they_get
> config
->size
)
1061 what_they_get
= config
->size
;
1063 /* Limit it to the size of the targets ``g'' response unless we have
1064 permission from the stub to use a larger packet size. */
1065 if (rs
->explicit_packet_size
== 0
1066 && rsa
->actual_register_packet_size
> 0
1067 && what_they_get
> rsa
->actual_register_packet_size
)
1068 what_they_get
= rsa
->actual_register_packet_size
;
1070 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1071 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1073 /* Make sure there is room in the global buffer for this packet
1074 (including its trailing NUL byte). */
1075 if (rs
->buf_size
< what_they_get
+ 1)
1077 rs
->buf_size
= 2 * what_they_get
;
1078 rs
->buf
= (char *) xrealloc (rs
->buf
, 2 * what_they_get
);
1081 return what_they_get
;
1084 /* Update the size of a read/write packet. If they user wants
1085 something really big then do a sanity check. */
1088 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
1090 int fixed_p
= config
->fixed_p
;
1091 long size
= config
->size
;
1094 error (_("Argument required (integer, `fixed' or `limited')."));
1095 else if (strcmp (args
, "hard") == 0
1096 || strcmp (args
, "fixed") == 0)
1098 else if (strcmp (args
, "soft") == 0
1099 || strcmp (args
, "limit") == 0)
1105 size
= strtoul (args
, &end
, 0);
1107 error (_("Invalid %s (bad syntax)."), config
->name
);
1109 /* Instead of explicitly capping the size of a packet to or
1110 disallowing it, the user is allowed to set the size to
1111 something arbitrarily large. */
1114 /* So that the query shows the correct value. */
1116 size
= DEFAULT_MAX_MEMORY_PACKET_SIZE
;
1119 if (fixed_p
&& !config
->fixed_p
)
1121 if (! query (_("The target may not be able to correctly handle a %s\n"
1122 "of %ld bytes. Change the packet size? "),
1123 config
->name
, size
))
1124 error (_("Packet size not changed."));
1126 /* Update the config. */
1127 config
->fixed_p
= fixed_p
;
1128 config
->size
= size
;
1132 show_memory_packet_size (struct memory_packet_config
*config
)
1134 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1135 if (config
->fixed_p
)
1136 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1137 get_memory_packet_size (config
));
1139 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1140 get_memory_packet_size (config
));
1143 static struct memory_packet_config memory_write_packet_config
=
1145 "memory-write-packet-size",
1149 set_memory_write_packet_size (char *args
, int from_tty
)
1151 set_memory_packet_size (args
, &memory_write_packet_config
);
1155 show_memory_write_packet_size (char *args
, int from_tty
)
1157 show_memory_packet_size (&memory_write_packet_config
);
1161 get_memory_write_packet_size (void)
1163 return get_memory_packet_size (&memory_write_packet_config
);
1166 static struct memory_packet_config memory_read_packet_config
=
1168 "memory-read-packet-size",
1172 set_memory_read_packet_size (char *args
, int from_tty
)
1174 set_memory_packet_size (args
, &memory_read_packet_config
);
1178 show_memory_read_packet_size (char *args
, int from_tty
)
1180 show_memory_packet_size (&memory_read_packet_config
);
1184 get_memory_read_packet_size (void)
1186 long size
= get_memory_packet_size (&memory_read_packet_config
);
1188 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1189 extra buffer size argument before the memory read size can be
1190 increased beyond this. */
1191 if (size
> get_remote_packet_size ())
1192 size
= get_remote_packet_size ();
1197 /* Generic configuration support for packets the stub optionally
1198 supports. Allows the user to specify the use of the packet as well
1199 as allowing GDB to auto-detect support in the remote stub. */
1203 PACKET_SUPPORT_UNKNOWN
= 0,
1208 struct packet_config
1213 /* If auto, GDB auto-detects support for this packet or feature,
1214 either through qSupported, or by trying the packet and looking
1215 at the response. If true, GDB assumes the target supports this
1216 packet. If false, the packet is disabled. Configs that don't
1217 have an associated command always have this set to auto. */
1218 enum auto_boolean detect
;
1220 /* Does the target support this packet? */
1221 enum packet_support support
;
1224 /* Analyze a packet's return value and update the packet config
1234 static enum packet_support
packet_config_support (struct packet_config
*config
);
1235 static enum packet_support
packet_support (int packet
);
1238 show_packet_config_cmd (struct packet_config
*config
)
1240 char *support
= "internal-error";
1242 switch (packet_config_support (config
))
1245 support
= "enabled";
1247 case PACKET_DISABLE
:
1248 support
= "disabled";
1250 case PACKET_SUPPORT_UNKNOWN
:
1251 support
= "unknown";
1254 switch (config
->detect
)
1256 case AUTO_BOOLEAN_AUTO
:
1257 printf_filtered (_("Support for the `%s' packet "
1258 "is auto-detected, currently %s.\n"),
1259 config
->name
, support
);
1261 case AUTO_BOOLEAN_TRUE
:
1262 case AUTO_BOOLEAN_FALSE
:
1263 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1264 config
->name
, support
);
1270 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1271 const char *title
, int legacy
)
1277 config
->name
= name
;
1278 config
->title
= title
;
1279 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1281 show_doc
= xstrprintf ("Show current use of remote "
1282 "protocol `%s' (%s) packet",
1284 /* set/show TITLE-packet {auto,on,off} */
1285 cmd_name
= xstrprintf ("%s-packet", title
);
1286 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1287 &config
->detect
, set_doc
,
1288 show_doc
, NULL
, /* help_doc */
1290 show_remote_protocol_packet_cmd
,
1291 &remote_set_cmdlist
, &remote_show_cmdlist
);
1292 /* The command code copies the documentation strings. */
1295 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1300 legacy_name
= xstrprintf ("%s-packet", name
);
1301 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1302 &remote_set_cmdlist
);
1303 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1304 &remote_show_cmdlist
);
1308 static enum packet_result
1309 packet_check_result (const char *buf
)
1313 /* The stub recognized the packet request. Check that the
1314 operation succeeded. */
1316 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1318 /* "Enn" - definitly an error. */
1319 return PACKET_ERROR
;
1321 /* Always treat "E." as an error. This will be used for
1322 more verbose error messages, such as E.memtypes. */
1323 if (buf
[0] == 'E' && buf
[1] == '.')
1324 return PACKET_ERROR
;
1326 /* The packet may or may not be OK. Just assume it is. */
1330 /* The stub does not support the packet. */
1331 return PACKET_UNKNOWN
;
1334 static enum packet_result
1335 packet_ok (const char *buf
, struct packet_config
*config
)
1337 enum packet_result result
;
1339 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1340 && config
->support
== PACKET_DISABLE
)
1341 internal_error (__FILE__
, __LINE__
,
1342 _("packet_ok: attempt to use a disabled packet"));
1344 result
= packet_check_result (buf
);
1349 /* The stub recognized the packet request. */
1350 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1353 fprintf_unfiltered (gdb_stdlog
,
1354 "Packet %s (%s) is supported\n",
1355 config
->name
, config
->title
);
1356 config
->support
= PACKET_ENABLE
;
1359 case PACKET_UNKNOWN
:
1360 /* The stub does not support the packet. */
1361 if (config
->detect
== AUTO_BOOLEAN_AUTO
1362 && config
->support
== PACKET_ENABLE
)
1364 /* If the stub previously indicated that the packet was
1365 supported then there is a protocol error. */
1366 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1367 config
->name
, config
->title
);
1369 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1371 /* The user set it wrong. */
1372 error (_("Enabled packet %s (%s) not recognized by stub"),
1373 config
->name
, config
->title
);
1377 fprintf_unfiltered (gdb_stdlog
,
1378 "Packet %s (%s) is NOT supported\n",
1379 config
->name
, config
->title
);
1380 config
->support
= PACKET_DISABLE
;
1401 PACKET_vFile_pwrite
,
1403 PACKET_vFile_unlink
,
1404 PACKET_vFile_readlink
,
1407 PACKET_qXfer_features
,
1408 PACKET_qXfer_exec_file
,
1409 PACKET_qXfer_libraries
,
1410 PACKET_qXfer_libraries_svr4
,
1411 PACKET_qXfer_memory_map
,
1412 PACKET_qXfer_spu_read
,
1413 PACKET_qXfer_spu_write
,
1414 PACKET_qXfer_osdata
,
1415 PACKET_qXfer_threads
,
1416 PACKET_qXfer_statictrace_read
,
1417 PACKET_qXfer_traceframe_info
,
1423 PACKET_QPassSignals
,
1424 PACKET_QCatchSyscalls
,
1425 PACKET_QProgramSignals
,
1427 PACKET_qSearch_memory
,
1430 PACKET_QStartNoAckMode
,
1432 PACKET_qXfer_siginfo_read
,
1433 PACKET_qXfer_siginfo_write
,
1436 /* Support for conditional tracepoints. */
1437 PACKET_ConditionalTracepoints
,
1439 /* Support for target-side breakpoint conditions. */
1440 PACKET_ConditionalBreakpoints
,
1442 /* Support for target-side breakpoint commands. */
1443 PACKET_BreakpointCommands
,
1445 /* Support for fast tracepoints. */
1446 PACKET_FastTracepoints
,
1448 /* Support for static tracepoints. */
1449 PACKET_StaticTracepoints
,
1451 /* Support for installing tracepoints while a trace experiment is
1453 PACKET_InstallInTrace
,
1457 PACKET_TracepointSource
,
1460 PACKET_QDisableRandomization
,
1462 PACKET_QTBuffer_size
,
1466 PACKET_qXfer_btrace
,
1468 /* Support for the QNonStop packet. */
1471 /* Support for the QThreadEvents packet. */
1472 PACKET_QThreadEvents
,
1474 /* Support for multi-process extensions. */
1475 PACKET_multiprocess_feature
,
1477 /* Support for enabling and disabling tracepoints while a trace
1478 experiment is running. */
1479 PACKET_EnableDisableTracepoints_feature
,
1481 /* Support for collecting strings using the tracenz bytecode. */
1482 PACKET_tracenz_feature
,
1484 /* Support for continuing to run a trace experiment while GDB is
1486 PACKET_DisconnectedTracing_feature
,
1488 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
1489 PACKET_augmented_libraries_svr4_read_feature
,
1491 /* Support for the qXfer:btrace-conf:read packet. */
1492 PACKET_qXfer_btrace_conf
,
1494 /* Support for the Qbtrace-conf:bts:size packet. */
1495 PACKET_Qbtrace_conf_bts_size
,
1497 /* Support for swbreak+ feature. */
1498 PACKET_swbreak_feature
,
1500 /* Support for hwbreak+ feature. */
1501 PACKET_hwbreak_feature
,
1503 /* Support for fork events. */
1504 PACKET_fork_event_feature
,
1506 /* Support for vfork events. */
1507 PACKET_vfork_event_feature
,
1509 /* Support for the Qbtrace-conf:pt:size packet. */
1510 PACKET_Qbtrace_conf_pt_size
,
1512 /* Support for exec events. */
1513 PACKET_exec_event_feature
,
1515 /* Support for query supported vCont actions. */
1516 PACKET_vContSupported
,
1518 /* Support remote CTRL-C. */
1521 /* Support TARGET_WAITKIND_NO_RESUMED. */
1527 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
1529 /* Returns the packet's corresponding "set remote foo-packet" command
1530 state. See struct packet_config for more details. */
1532 static enum auto_boolean
1533 packet_set_cmd_state (int packet
)
1535 return remote_protocol_packets
[packet
].detect
;
1538 /* Returns whether a given packet or feature is supported. This takes
1539 into account the state of the corresponding "set remote foo-packet"
1540 command, which may be used to bypass auto-detection. */
1542 static enum packet_support
1543 packet_config_support (struct packet_config
*config
)
1545 switch (config
->detect
)
1547 case AUTO_BOOLEAN_TRUE
:
1548 return PACKET_ENABLE
;
1549 case AUTO_BOOLEAN_FALSE
:
1550 return PACKET_DISABLE
;
1551 case AUTO_BOOLEAN_AUTO
:
1552 return config
->support
;
1554 gdb_assert_not_reached (_("bad switch"));
1558 /* Same as packet_config_support, but takes the packet's enum value as
1561 static enum packet_support
1562 packet_support (int packet
)
1564 struct packet_config
*config
= &remote_protocol_packets
[packet
];
1566 return packet_config_support (config
);
1570 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
1571 struct cmd_list_element
*c
,
1574 struct packet_config
*packet
;
1576 for (packet
= remote_protocol_packets
;
1577 packet
< &remote_protocol_packets
[PACKET_MAX
];
1580 if (&packet
->detect
== c
->var
)
1582 show_packet_config_cmd (packet
);
1586 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
1590 /* Should we try one of the 'Z' requests? */
1594 Z_PACKET_SOFTWARE_BP
,
1595 Z_PACKET_HARDWARE_BP
,
1602 /* For compatibility with older distributions. Provide a ``set remote
1603 Z-packet ...'' command that updates all the Z packet types. */
1605 static enum auto_boolean remote_Z_packet_detect
;
1608 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1609 struct cmd_list_element
*c
)
1613 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1614 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1618 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1619 struct cmd_list_element
*c
,
1624 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1626 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1630 /* Returns true if the multi-process extensions are in effect. */
1633 remote_multi_process_p (struct remote_state
*rs
)
1635 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
1638 /* Returns true if fork events are supported. */
1641 remote_fork_event_p (struct remote_state
*rs
)
1643 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
1646 /* Returns true if vfork events are supported. */
1649 remote_vfork_event_p (struct remote_state
*rs
)
1651 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
1654 /* Returns true if exec events are supported. */
1657 remote_exec_event_p (struct remote_state
*rs
)
1659 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
1662 /* Insert fork catchpoint target routine. If fork events are enabled
1663 then return success, nothing more to do. */
1666 remote_insert_fork_catchpoint (struct target_ops
*ops
, int pid
)
1668 struct remote_state
*rs
= get_remote_state ();
1670 return !remote_fork_event_p (rs
);
1673 /* Remove fork catchpoint target routine. Nothing to do, just
1677 remote_remove_fork_catchpoint (struct target_ops
*ops
, int pid
)
1682 /* Insert vfork catchpoint target routine. If vfork events are enabled
1683 then return success, nothing more to do. */
1686 remote_insert_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1688 struct remote_state
*rs
= get_remote_state ();
1690 return !remote_vfork_event_p (rs
);
1693 /* Remove vfork catchpoint target routine. Nothing to do, just
1697 remote_remove_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1702 /* Insert exec catchpoint target routine. If exec events are
1703 enabled, just return success. */
1706 remote_insert_exec_catchpoint (struct target_ops
*ops
, int pid
)
1708 struct remote_state
*rs
= get_remote_state ();
1710 return !remote_exec_event_p (rs
);
1713 /* Remove exec catchpoint target routine. Nothing to do, just
1717 remote_remove_exec_catchpoint (struct target_ops
*ops
, int pid
)
1723 /* Asynchronous signal handle registered as event loop source for
1724 when we have pending events ready to be passed to the core. */
1726 static struct async_event_handler
*remote_async_inferior_event_token
;
1730 static ptid_t magic_null_ptid
;
1731 static ptid_t not_sent_ptid
;
1732 static ptid_t any_thread_ptid
;
1734 /* Find out if the stub attached to PID (and hence GDB should offer to
1735 detach instead of killing it when bailing out). */
1738 remote_query_attached (int pid
)
1740 struct remote_state
*rs
= get_remote_state ();
1741 size_t size
= get_remote_packet_size ();
1743 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
1746 if (remote_multi_process_p (rs
))
1747 xsnprintf (rs
->buf
, size
, "qAttached:%x", pid
);
1749 xsnprintf (rs
->buf
, size
, "qAttached");
1752 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1754 switch (packet_ok (rs
->buf
,
1755 &remote_protocol_packets
[PACKET_qAttached
]))
1758 if (strcmp (rs
->buf
, "1") == 0)
1762 warning (_("Remote failure reply: %s"), rs
->buf
);
1764 case PACKET_UNKNOWN
:
1771 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1772 has been invented by GDB, instead of reported by the target. Since
1773 we can be connected to a remote system before before knowing about
1774 any inferior, mark the target with execution when we find the first
1775 inferior. If ATTACHED is 1, then we had just attached to this
1776 inferior. If it is 0, then we just created this inferior. If it
1777 is -1, then try querying the remote stub to find out if it had
1778 attached to the inferior or not. If TRY_OPEN_EXEC is true then
1779 attempt to open this inferior's executable as the main executable
1780 if no main executable is open already. */
1782 static struct inferior
*
1783 remote_add_inferior (int fake_pid_p
, int pid
, int attached
,
1786 struct inferior
*inf
;
1788 /* Check whether this process we're learning about is to be
1789 considered attached, or if is to be considered to have been
1790 spawned by the stub. */
1792 attached
= remote_query_attached (pid
);
1794 if (gdbarch_has_global_solist (target_gdbarch ()))
1796 /* If the target shares code across all inferiors, then every
1797 attach adds a new inferior. */
1798 inf
= add_inferior (pid
);
1800 /* ... and every inferior is bound to the same program space.
1801 However, each inferior may still have its own address
1803 inf
->aspace
= maybe_new_address_space ();
1804 inf
->pspace
= current_program_space
;
1808 /* In the traditional debugging scenario, there's a 1-1 match
1809 between program/address spaces. We simply bind the inferior
1810 to the program space's address space. */
1811 inf
= current_inferior ();
1812 inferior_appeared (inf
, pid
);
1815 inf
->attach_flag
= attached
;
1816 inf
->fake_pid_p
= fake_pid_p
;
1818 /* If no main executable is currently open then attempt to
1819 open the file that was executed to create this inferior. */
1820 if (try_open_exec
&& get_exec_file (0) == NULL
)
1821 exec_file_locate_attach (pid
, 0, 1);
1826 static struct private_thread_info
*
1827 get_private_info_thread (struct thread_info
*info
);
1829 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1830 according to RUNNING. */
1833 remote_add_thread (ptid_t ptid
, int running
, int executing
)
1835 struct remote_state
*rs
= get_remote_state ();
1836 struct thread_info
*thread
;
1838 /* GDB historically didn't pull threads in the initial connection
1839 setup. If the remote target doesn't even have a concept of
1840 threads (e.g., a bare-metal target), even if internally we
1841 consider that a single-threaded target, mentioning a new thread
1842 might be confusing to the user. Be silent then, preserving the
1843 age old behavior. */
1844 if (rs
->starting_up
)
1845 thread
= add_thread_silent (ptid
);
1847 thread
= add_thread (ptid
);
1849 get_private_info_thread (thread
)->vcont_resumed
= executing
;
1850 set_executing (ptid
, executing
);
1851 set_running (ptid
, running
);
1854 /* Come here when we learn about a thread id from the remote target.
1855 It may be the first time we hear about such thread, so take the
1856 opportunity to add it to GDB's thread list. In case this is the
1857 first time we're noticing its corresponding inferior, add it to
1858 GDB's inferior list as well. EXECUTING indicates whether the
1859 thread is (internally) executing or stopped. */
1862 remote_notice_new_inferior (ptid_t currthread
, int executing
)
1864 /* In non-stop mode, we assume new found threads are (externally)
1865 running until proven otherwise with a stop reply. In all-stop,
1866 we can only get here if all threads are stopped. */
1867 int running
= target_is_non_stop_p () ? 1 : 0;
1869 /* If this is a new thread, add it to GDB's thread list.
1870 If we leave it up to WFI to do this, bad things will happen. */
1872 if (in_thread_list (currthread
) && is_exited (currthread
))
1874 /* We're seeing an event on a thread id we knew had exited.
1875 This has to be a new thread reusing the old id. Add it. */
1876 remote_add_thread (currthread
, running
, executing
);
1880 if (!in_thread_list (currthread
))
1882 struct inferior
*inf
= NULL
;
1883 int pid
= ptid_get_pid (currthread
);
1885 if (ptid_is_pid (inferior_ptid
)
1886 && pid
== ptid_get_pid (inferior_ptid
))
1888 /* inferior_ptid has no thread member yet. This can happen
1889 with the vAttach -> remote_wait,"TAAthread:" path if the
1890 stub doesn't support qC. This is the first stop reported
1891 after an attach, so this is the main thread. Update the
1892 ptid in the thread list. */
1893 if (in_thread_list (pid_to_ptid (pid
)))
1894 thread_change_ptid (inferior_ptid
, currthread
);
1897 remote_add_thread (currthread
, running
, executing
);
1898 inferior_ptid
= currthread
;
1903 if (ptid_equal (magic_null_ptid
, inferior_ptid
))
1905 /* inferior_ptid is not set yet. This can happen with the
1906 vRun -> remote_wait,"TAAthread:" path if the stub
1907 doesn't support qC. This is the first stop reported
1908 after an attach, so this is the main thread. Update the
1909 ptid in the thread list. */
1910 thread_change_ptid (inferior_ptid
, currthread
);
1914 /* When connecting to a target remote, or to a target
1915 extended-remote which already was debugging an inferior, we
1916 may not know about it yet. Add it before adding its child
1917 thread, so notifications are emitted in a sensible order. */
1918 if (!in_inferior_list (ptid_get_pid (currthread
)))
1920 struct remote_state
*rs
= get_remote_state ();
1921 int fake_pid_p
= !remote_multi_process_p (rs
);
1923 inf
= remote_add_inferior (fake_pid_p
,
1924 ptid_get_pid (currthread
), -1, 1);
1927 /* This is really a new thread. Add it. */
1928 remote_add_thread (currthread
, running
, executing
);
1930 /* If we found a new inferior, let the common code do whatever
1931 it needs to with it (e.g., read shared libraries, insert
1932 breakpoints), unless we're just setting up an all-stop
1936 struct remote_state
*rs
= get_remote_state ();
1938 if (!rs
->starting_up
)
1939 notice_new_inferior (currthread
, executing
, 0);
1944 /* Return THREAD's private thread data, creating it if necessary. */
1946 static struct private_thread_info
*
1947 get_private_info_thread (struct thread_info
*thread
)
1949 gdb_assert (thread
!= NULL
);
1951 if (thread
->priv
== NULL
)
1953 struct private_thread_info
*priv
= XNEW (struct private_thread_info
);
1955 thread
->private_dtor
= free_private_thread_info
;
1956 thread
->priv
= priv
;
1962 priv
->last_resume_step
= 0;
1963 priv
->last_resume_sig
= GDB_SIGNAL_0
;
1964 priv
->vcont_resumed
= 0;
1967 return thread
->priv
;
1970 /* Return PTID's private thread data, creating it if necessary. */
1972 static struct private_thread_info
*
1973 get_private_info_ptid (ptid_t ptid
)
1975 struct thread_info
*info
= find_thread_ptid (ptid
);
1977 return get_private_info_thread (info
);
1980 /* Call this function as a result of
1981 1) A halt indication (T packet) containing a thread id
1982 2) A direct query of currthread
1983 3) Successful execution of set thread */
1986 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
1988 rs
->general_thread
= currthread
;
1991 /* If 'QPassSignals' is supported, tell the remote stub what signals
1992 it can simply pass through to the inferior without reporting. */
1995 remote_pass_signals (struct target_ops
*self
,
1996 int numsigs
, unsigned char *pass_signals
)
1998 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2000 char *pass_packet
, *p
;
2002 struct remote_state
*rs
= get_remote_state ();
2004 gdb_assert (numsigs
< 256);
2005 for (i
= 0; i
< numsigs
; i
++)
2007 if (pass_signals
[i
])
2010 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2011 strcpy (pass_packet
, "QPassSignals:");
2012 p
= pass_packet
+ strlen (pass_packet
);
2013 for (i
= 0; i
< numsigs
; i
++)
2015 if (pass_signals
[i
])
2018 *p
++ = tohex (i
>> 4);
2019 *p
++ = tohex (i
& 15);
2028 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2030 putpkt (pass_packet
);
2031 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2032 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2033 if (rs
->last_pass_packet
)
2034 xfree (rs
->last_pass_packet
);
2035 rs
->last_pass_packet
= pass_packet
;
2038 xfree (pass_packet
);
2042 /* If 'QCatchSyscalls' is supported, tell the remote stub
2043 to report syscalls to GDB. */
2046 remote_set_syscall_catchpoint (struct target_ops
*self
,
2047 int pid
, int needed
, int any_count
,
2048 int table_size
, int *table
)
2051 enum packet_result result
;
2054 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2056 /* Not supported. */
2060 if (needed
&& !any_count
)
2064 /* Count how many syscalls are to be caught (table[sysno] != 0). */
2065 for (i
= 0; i
< table_size
; i
++)
2074 fprintf_unfiltered (gdb_stdlog
,
2075 "remote_set_syscall_catchpoint "
2076 "pid %d needed %d any_count %d n_sysno %d\n",
2077 pid
, needed
, any_count
, n_sysno
);
2082 /* Prepare a packet with the sysno list, assuming max 8+1
2083 characters for a sysno. If the resulting packet size is too
2084 big, fallback on the non-selective packet. */
2085 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2087 catch_packet
= (char *) xmalloc (maxpktsz
);
2088 strcpy (catch_packet
, "QCatchSyscalls:1");
2097 /* Add in catch_packet each syscall to be caught (table[i] != 0). */
2098 for (i
= 0; i
< table_size
; i
++)
2101 p
+= xsnprintf (p
, catch_packet
+ maxpktsz
- p
, ";%x", i
);
2104 if (strlen (catch_packet
) > get_remote_packet_size ())
2106 /* catch_packet too big. Fallback to less efficient
2107 non selective mode, with GDB doing the filtering. */
2108 catch_packet
[sizeof ("QCatchSyscalls:1") - 1] = 0;
2112 catch_packet
= xstrdup ("QCatchSyscalls:0");
2115 struct cleanup
*old_chain
= make_cleanup (xfree
, catch_packet
);
2116 struct remote_state
*rs
= get_remote_state ();
2118 putpkt (catch_packet
);
2119 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2120 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2121 do_cleanups (old_chain
);
2122 if (result
== PACKET_OK
)
2129 /* If 'QProgramSignals' is supported, tell the remote stub what
2130 signals it should pass through to the inferior when detaching. */
2133 remote_program_signals (struct target_ops
*self
,
2134 int numsigs
, unsigned char *signals
)
2136 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2140 struct remote_state
*rs
= get_remote_state ();
2142 gdb_assert (numsigs
< 256);
2143 for (i
= 0; i
< numsigs
; i
++)
2148 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2149 strcpy (packet
, "QProgramSignals:");
2150 p
= packet
+ strlen (packet
);
2151 for (i
= 0; i
< numsigs
; i
++)
2153 if (signal_pass_state (i
))
2156 *p
++ = tohex (i
>> 4);
2157 *p
++ = tohex (i
& 15);
2166 if (!rs
->last_program_signals_packet
2167 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2170 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2171 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2172 xfree (rs
->last_program_signals_packet
);
2173 rs
->last_program_signals_packet
= packet
;
2180 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2181 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2182 thread. If GEN is set, set the general thread, if not, then set
2183 the step/continue thread. */
2185 set_thread (struct ptid ptid
, int gen
)
2187 struct remote_state
*rs
= get_remote_state ();
2188 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2189 char *buf
= rs
->buf
;
2190 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
2192 if (ptid_equal (state
, ptid
))
2196 *buf
++ = gen
? 'g' : 'c';
2197 if (ptid_equal (ptid
, magic_null_ptid
))
2198 xsnprintf (buf
, endbuf
- buf
, "0");
2199 else if (ptid_equal (ptid
, any_thread_ptid
))
2200 xsnprintf (buf
, endbuf
- buf
, "0");
2201 else if (ptid_equal (ptid
, minus_one_ptid
))
2202 xsnprintf (buf
, endbuf
- buf
, "-1");
2204 write_ptid (buf
, endbuf
, ptid
);
2206 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2208 rs
->general_thread
= ptid
;
2210 rs
->continue_thread
= ptid
;
2214 set_general_thread (struct ptid ptid
)
2216 set_thread (ptid
, 1);
2220 set_continue_thread (struct ptid ptid
)
2222 set_thread (ptid
, 0);
2225 /* Change the remote current process. Which thread within the process
2226 ends up selected isn't important, as long as it is the same process
2227 as what INFERIOR_PTID points to.
2229 This comes from that fact that there is no explicit notion of
2230 "selected process" in the protocol. The selected process for
2231 general operations is the process the selected general thread
2235 set_general_process (void)
2237 struct remote_state
*rs
= get_remote_state ();
2239 /* If the remote can't handle multiple processes, don't bother. */
2240 if (!remote_multi_process_p (rs
))
2243 /* We only need to change the remote current thread if it's pointing
2244 at some other process. */
2245 if (ptid_get_pid (rs
->general_thread
) != ptid_get_pid (inferior_ptid
))
2246 set_general_thread (inferior_ptid
);
2250 /* Return nonzero if this is the main thread that we made up ourselves
2251 to model non-threaded targets as single-threaded. */
2254 remote_thread_always_alive (struct target_ops
*ops
, ptid_t ptid
)
2256 if (ptid_equal (ptid
, magic_null_ptid
))
2257 /* The main thread is always alive. */
2260 if (ptid_get_pid (ptid
) != 0 && ptid_get_lwp (ptid
) == 0)
2261 /* The main thread is always alive. This can happen after a
2262 vAttach, if the remote side doesn't support
2269 /* Return nonzero if the thread PTID is still alive on the remote
2273 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2275 struct remote_state
*rs
= get_remote_state ();
2278 /* Check if this is a thread that we made up ourselves to model
2279 non-threaded targets as single-threaded. */
2280 if (remote_thread_always_alive (ops
, ptid
))
2284 endp
= rs
->buf
+ get_remote_packet_size ();
2287 write_ptid (p
, endp
, ptid
);
2290 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2291 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2294 /* Return a pointer to a thread name if we know it and NULL otherwise.
2295 The thread_info object owns the memory for the name. */
2298 remote_thread_name (struct target_ops
*ops
, struct thread_info
*info
)
2300 if (info
->priv
!= NULL
)
2301 return info
->priv
->name
;
2306 /* About these extended threadlist and threadinfo packets. They are
2307 variable length packets but, the fields within them are often fixed
2308 length. They are redundent enough to send over UDP as is the
2309 remote protocol in general. There is a matching unit test module
2312 /* WARNING: This threadref data structure comes from the remote O.S.,
2313 libstub protocol encoding, and remote.c. It is not particularly
2316 /* Right now, the internal structure is int. We want it to be bigger.
2317 Plan to fix this. */
2319 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2321 /* gdb_ext_thread_info is an internal GDB data structure which is
2322 equivalent to the reply of the remote threadinfo packet. */
2324 struct gdb_ext_thread_info
2326 threadref threadid
; /* External form of thread reference. */
2327 int active
; /* Has state interesting to GDB?
2329 char display
[256]; /* Brief state display, name,
2330 blocked/suspended. */
2331 char shortname
[32]; /* To be used to name threads. */
2332 char more_display
[256]; /* Long info, statistics, queue depth,
2336 /* The volume of remote transfers can be limited by submitting
2337 a mask containing bits specifying the desired information.
2338 Use a union of these values as the 'selection' parameter to
2339 get_thread_info. FIXME: Make these TAG names more thread specific. */
2341 #define TAG_THREADID 1
2342 #define TAG_EXISTS 2
2343 #define TAG_DISPLAY 4
2344 #define TAG_THREADNAME 8
2345 #define TAG_MOREDISPLAY 16
2347 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2349 static char *unpack_nibble (char *buf
, int *val
);
2351 static char *unpack_byte (char *buf
, int *value
);
2353 static char *pack_int (char *buf
, int value
);
2355 static char *unpack_int (char *buf
, int *value
);
2357 static char *unpack_string (char *src
, char *dest
, int length
);
2359 static char *pack_threadid (char *pkt
, threadref
*id
);
2361 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2363 void int_to_threadref (threadref
*id
, int value
);
2365 static int threadref_to_int (threadref
*ref
);
2367 static void copy_threadref (threadref
*dest
, threadref
*src
);
2369 static int threadmatch (threadref
*dest
, threadref
*src
);
2371 static char *pack_threadinfo_request (char *pkt
, int mode
,
2374 static int remote_unpack_thread_info_response (char *pkt
,
2375 threadref
*expectedref
,
2376 struct gdb_ext_thread_info
2380 static int remote_get_threadinfo (threadref
*threadid
,
2381 int fieldset
, /*TAG mask */
2382 struct gdb_ext_thread_info
*info
);
2384 static char *pack_threadlist_request (char *pkt
, int startflag
,
2386 threadref
*nextthread
);
2388 static int parse_threadlist_response (char *pkt
,
2390 threadref
*original_echo
,
2391 threadref
*resultlist
,
2394 static int remote_get_threadlist (int startflag
,
2395 threadref
*nextthread
,
2399 threadref
*threadlist
);
2401 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
2403 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
2404 void *context
, int looplimit
);
2406 static int remote_newthread_step (threadref
*ref
, void *context
);
2409 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2410 buffer we're allowed to write to. Returns
2411 BUF+CHARACTERS_WRITTEN. */
2414 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2417 struct remote_state
*rs
= get_remote_state ();
2419 if (remote_multi_process_p (rs
))
2421 pid
= ptid_get_pid (ptid
);
2423 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2425 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2427 tid
= ptid_get_lwp (ptid
);
2429 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2431 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2436 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
2437 passed the last parsed char. Returns null_ptid on error. */
2440 read_ptid (char *buf
, char **obuf
)
2444 ULONGEST pid
= 0, tid
= 0;
2448 /* Multi-process ptid. */
2449 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2451 error (_("invalid remote ptid: %s"), p
);
2454 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2457 return ptid_build (pid
, tid
, 0);
2460 /* No multi-process. Just a tid. */
2461 pp
= unpack_varlen_hex (p
, &tid
);
2463 /* Return null_ptid when no thread id is found. */
2471 /* Since the stub is not sending a process id, then default to
2472 what's in inferior_ptid, unless it's null at this point. If so,
2473 then since there's no way to know the pid of the reported
2474 threads, use the magic number. */
2475 if (ptid_equal (inferior_ptid
, null_ptid
))
2476 pid
= ptid_get_pid (magic_null_ptid
);
2478 pid
= ptid_get_pid (inferior_ptid
);
2482 return ptid_build (pid
, tid
, 0);
2488 if (ch
>= 'a' && ch
<= 'f')
2489 return ch
- 'a' + 10;
2490 if (ch
>= '0' && ch
<= '9')
2492 if (ch
>= 'A' && ch
<= 'F')
2493 return ch
- 'A' + 10;
2498 stub_unpack_int (char *buff
, int fieldlength
)
2505 nibble
= stubhex (*buff
++);
2509 retval
= retval
<< 4;
2515 unpack_nibble (char *buf
, int *val
)
2517 *val
= fromhex (*buf
++);
2522 unpack_byte (char *buf
, int *value
)
2524 *value
= stub_unpack_int (buf
, 2);
2529 pack_int (char *buf
, int value
)
2531 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
2532 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
2533 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
2534 buf
= pack_hex_byte (buf
, (value
& 0xff));
2539 unpack_int (char *buf
, int *value
)
2541 *value
= stub_unpack_int (buf
, 8);
2545 #if 0 /* Currently unused, uncomment when needed. */
2546 static char *pack_string (char *pkt
, char *string
);
2549 pack_string (char *pkt
, char *string
)
2554 len
= strlen (string
);
2556 len
= 200; /* Bigger than most GDB packets, junk??? */
2557 pkt
= pack_hex_byte (pkt
, len
);
2561 if ((ch
== '\0') || (ch
== '#'))
2562 ch
= '*'; /* Protect encapsulation. */
2567 #endif /* 0 (unused) */
2570 unpack_string (char *src
, char *dest
, int length
)
2579 pack_threadid (char *pkt
, threadref
*id
)
2582 unsigned char *altid
;
2584 altid
= (unsigned char *) id
;
2585 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
2587 pkt
= pack_hex_byte (pkt
, *altid
++);
2593 unpack_threadid (char *inbuf
, threadref
*id
)
2596 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2599 altref
= (char *) id
;
2601 while (inbuf
< limit
)
2603 x
= stubhex (*inbuf
++);
2604 y
= stubhex (*inbuf
++);
2605 *altref
++ = (x
<< 4) | y
;
2610 /* Externally, threadrefs are 64 bits but internally, they are still
2611 ints. This is due to a mismatch of specifications. We would like
2612 to use 64bit thread references internally. This is an adapter
2616 int_to_threadref (threadref
*id
, int value
)
2618 unsigned char *scan
;
2620 scan
= (unsigned char *) id
;
2626 *scan
++ = (value
>> 24) & 0xff;
2627 *scan
++ = (value
>> 16) & 0xff;
2628 *scan
++ = (value
>> 8) & 0xff;
2629 *scan
++ = (value
& 0xff);
2633 threadref_to_int (threadref
*ref
)
2636 unsigned char *scan
;
2642 value
= (value
<< 8) | ((*scan
++) & 0xff);
2647 copy_threadref (threadref
*dest
, threadref
*src
)
2650 unsigned char *csrc
, *cdest
;
2652 csrc
= (unsigned char *) src
;
2653 cdest
= (unsigned char *) dest
;
2660 threadmatch (threadref
*dest
, threadref
*src
)
2662 /* Things are broken right now, so just assume we got a match. */
2664 unsigned char *srcp
, *destp
;
2666 srcp
= (char *) src
;
2667 destp
= (char *) dest
;
2671 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2678 threadid:1, # always request threadid
2685 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2688 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2690 *pkt
++ = 'q'; /* Info Query */
2691 *pkt
++ = 'P'; /* process or thread info */
2692 pkt
= pack_int (pkt
, mode
); /* mode */
2693 pkt
= pack_threadid (pkt
, id
); /* threadid */
2694 *pkt
= '\0'; /* terminate */
2698 /* These values tag the fields in a thread info response packet. */
2699 /* Tagging the fields allows us to request specific fields and to
2700 add more fields as time goes by. */
2702 #define TAG_THREADID 1 /* Echo the thread identifier. */
2703 #define TAG_EXISTS 2 /* Is this process defined enough to
2704 fetch registers and its stack? */
2705 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2706 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2707 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2711 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2712 struct gdb_ext_thread_info
*info
)
2714 struct remote_state
*rs
= get_remote_state ();
2718 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2721 /* info->threadid = 0; FIXME: implement zero_threadref. */
2723 info
->display
[0] = '\0';
2724 info
->shortname
[0] = '\0';
2725 info
->more_display
[0] = '\0';
2727 /* Assume the characters indicating the packet type have been
2729 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2730 pkt
= unpack_threadid (pkt
, &ref
);
2733 warning (_("Incomplete response to threadinfo request."));
2734 if (!threadmatch (&ref
, expectedref
))
2735 { /* This is an answer to a different request. */
2736 warning (_("ERROR RMT Thread info mismatch."));
2739 copy_threadref (&info
->threadid
, &ref
);
2741 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2743 /* Packets are terminated with nulls. */
2744 while ((pkt
< limit
) && mask
&& *pkt
)
2746 pkt
= unpack_int (pkt
, &tag
); /* tag */
2747 pkt
= unpack_byte (pkt
, &length
); /* length */
2748 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2750 warning (_("ERROR RMT: threadinfo tag mismatch."));
2754 if (tag
== TAG_THREADID
)
2758 warning (_("ERROR RMT: length of threadid is not 16."));
2762 pkt
= unpack_threadid (pkt
, &ref
);
2763 mask
= mask
& ~TAG_THREADID
;
2766 if (tag
== TAG_EXISTS
)
2768 info
->active
= stub_unpack_int (pkt
, length
);
2770 mask
= mask
& ~(TAG_EXISTS
);
2773 warning (_("ERROR RMT: 'exists' length too long."));
2779 if (tag
== TAG_THREADNAME
)
2781 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2782 mask
= mask
& ~TAG_THREADNAME
;
2785 if (tag
== TAG_DISPLAY
)
2787 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2788 mask
= mask
& ~TAG_DISPLAY
;
2791 if (tag
== TAG_MOREDISPLAY
)
2793 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2794 mask
= mask
& ~TAG_MOREDISPLAY
;
2797 warning (_("ERROR RMT: unknown thread info tag."));
2798 break; /* Not a tag we know about. */
2804 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2805 struct gdb_ext_thread_info
*info
)
2807 struct remote_state
*rs
= get_remote_state ();
2810 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2812 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2814 if (rs
->buf
[0] == '\0')
2817 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2822 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2825 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2826 threadref
*nextthread
)
2828 *pkt
++ = 'q'; /* info query packet */
2829 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2830 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2831 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2832 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2837 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2840 parse_threadlist_response (char *pkt
, int result_limit
,
2841 threadref
*original_echo
, threadref
*resultlist
,
2844 struct remote_state
*rs
= get_remote_state ();
2846 int count
, resultcount
, done
;
2849 /* Assume the 'q' and 'M chars have been stripped. */
2850 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2851 /* done parse past here */
2852 pkt
= unpack_byte (pkt
, &count
); /* count field */
2853 pkt
= unpack_nibble (pkt
, &done
);
2854 /* The first threadid is the argument threadid. */
2855 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2856 while ((count
-- > 0) && (pkt
< limit
))
2858 pkt
= unpack_threadid (pkt
, resultlist
++);
2859 if (resultcount
++ >= result_limit
)
2867 /* Fetch the next batch of threads from the remote. Returns -1 if the
2868 qL packet is not supported, 0 on error and 1 on success. */
2871 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2872 int *done
, int *result_count
, threadref
*threadlist
)
2874 struct remote_state
*rs
= get_remote_state ();
2877 /* Trancate result limit to be smaller than the packet size. */
2878 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
2879 >= get_remote_packet_size ())
2880 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2882 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2884 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2885 if (*rs
->buf
== '\0')
2887 /* Packet not supported. */
2892 parse_threadlist_response (rs
->buf
+ 2, result_limit
,
2893 &rs
->echo_nextthread
, threadlist
, done
);
2895 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
2897 /* FIXME: This is a good reason to drop the packet. */
2898 /* Possably, there is a duplicate response. */
2900 retransmit immediatly - race conditions
2901 retransmit after timeout - yes
2903 wait for packet, then exit
2905 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2906 return 0; /* I choose simply exiting. */
2908 if (*result_count
<= 0)
2912 warning (_("RMT ERROR : failed to get remote thread list."));
2915 return result
; /* break; */
2917 if (*result_count
> result_limit
)
2920 warning (_("RMT ERROR: threadlist response longer than requested."));
2926 /* Fetch the list of remote threads, with the qL packet, and call
2927 STEPFUNCTION for each thread found. Stops iterating and returns 1
2928 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2929 STEPFUNCTION returns false. If the packet is not supported,
2933 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2936 struct remote_state
*rs
= get_remote_state ();
2937 int done
, i
, result_count
;
2945 if (loopcount
++ > looplimit
)
2948 warning (_("Remote fetch threadlist -infinite loop-."));
2951 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
2952 MAXTHREADLISTRESULTS
,
2953 &done
, &result_count
,
2954 rs
->resultthreadlist
);
2957 /* Clear for later iterations. */
2959 /* Setup to resume next batch of thread references, set nextthread. */
2960 if (result_count
>= 1)
2961 copy_threadref (&rs
->nextthread
,
2962 &rs
->resultthreadlist
[result_count
- 1]);
2964 while (result_count
--)
2966 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
2976 /* A thread found on the remote target. */
2978 typedef struct thread_item
2980 /* The thread's PTID. */
2983 /* The thread's extra info. May be NULL. */
2986 /* The thread's name. May be NULL. */
2989 /* The core the thread was running on. -1 if not known. */
2992 DEF_VEC_O(thread_item_t
);
2994 /* Context passed around to the various methods listing remote
2995 threads. As new threads are found, they're added to the ITEMS
2998 struct threads_listing_context
3000 /* The threads found on the remote target. */
3001 VEC (thread_item_t
) *items
;
3004 /* Discard the contents of the constructed thread listing context. */
3007 clear_threads_listing_context (void *p
)
3009 struct threads_listing_context
*context
3010 = (struct threads_listing_context
*) p
;
3012 struct thread_item
*item
;
3014 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3016 xfree (item
->extra
);
3020 VEC_free (thread_item_t
, context
->items
);
3023 /* Remove the thread specified as the related_pid field of WS
3024 from the CONTEXT list. */
3027 threads_listing_context_remove (struct target_waitstatus
*ws
,
3028 struct threads_listing_context
*context
)
3030 struct thread_item
*item
;
3032 ptid_t child_ptid
= ws
->value
.related_pid
;
3034 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3036 if (ptid_equal (item
->ptid
, child_ptid
))
3038 VEC_ordered_remove (thread_item_t
, context
->items
, i
);
3045 remote_newthread_step (threadref
*ref
, void *data
)
3047 struct threads_listing_context
*context
3048 = (struct threads_listing_context
*) data
;
3049 struct thread_item item
;
3050 int pid
= ptid_get_pid (inferior_ptid
);
3052 item
.ptid
= ptid_build (pid
, threadref_to_int (ref
), 0);
3057 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3059 return 1; /* continue iterator */
3062 #define CRAZY_MAX_THREADS 1000
3065 remote_current_thread (ptid_t oldpid
)
3067 struct remote_state
*rs
= get_remote_state ();
3070 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3071 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3076 result
= read_ptid (&rs
->buf
[2], &obuf
);
3077 if (*obuf
!= '\0' && remote_debug
)
3078 fprintf_unfiltered (gdb_stdlog
,
3079 "warning: garbage in qC reply\n");
3087 /* List remote threads using the deprecated qL packet. */
3090 remote_get_threads_with_ql (struct target_ops
*ops
,
3091 struct threads_listing_context
*context
)
3093 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3094 CRAZY_MAX_THREADS
) >= 0)
3100 #if defined(HAVE_LIBEXPAT)
3103 start_thread (struct gdb_xml_parser
*parser
,
3104 const struct gdb_xml_element
*element
,
3105 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
3107 struct threads_listing_context
*data
3108 = (struct threads_listing_context
*) user_data
;
3110 struct thread_item item
;
3112 struct gdb_xml_value
*attr
;
3114 id
= (char *) xml_find_attribute (attributes
, "id")->value
;
3115 item
.ptid
= read_ptid (id
, NULL
);
3117 attr
= xml_find_attribute (attributes
, "core");
3119 item
.core
= *(ULONGEST
*) attr
->value
;
3123 attr
= xml_find_attribute (attributes
, "name");
3124 item
.name
= attr
!= NULL
? xstrdup ((const char *) attr
->value
) : NULL
;
3128 VEC_safe_push (thread_item_t
, data
->items
, &item
);
3132 end_thread (struct gdb_xml_parser
*parser
,
3133 const struct gdb_xml_element
*element
,
3134 void *user_data
, const char *body_text
)
3136 struct threads_listing_context
*data
3137 = (struct threads_listing_context
*) user_data
;
3139 if (body_text
&& *body_text
)
3140 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
3143 const struct gdb_xml_attribute thread_attributes
[] = {
3144 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3145 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3146 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3147 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3150 const struct gdb_xml_element thread_children
[] = {
3151 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3154 const struct gdb_xml_element threads_children
[] = {
3155 { "thread", thread_attributes
, thread_children
,
3156 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3157 start_thread
, end_thread
},
3158 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3161 const struct gdb_xml_element threads_elements
[] = {
3162 { "threads", NULL
, threads_children
,
3163 GDB_XML_EF_NONE
, NULL
, NULL
},
3164 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3169 /* List remote threads using qXfer:threads:read. */
3172 remote_get_threads_with_qxfer (struct target_ops
*ops
,
3173 struct threads_listing_context
*context
)
3175 #if defined(HAVE_LIBEXPAT)
3176 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3178 char *xml
= target_read_stralloc (ops
, TARGET_OBJECT_THREADS
, NULL
);
3179 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
3181 if (xml
!= NULL
&& *xml
!= '\0')
3183 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3184 threads_elements
, xml
, context
);
3187 do_cleanups (back_to
);
3195 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3198 remote_get_threads_with_qthreadinfo (struct target_ops
*ops
,
3199 struct threads_listing_context
*context
)
3201 struct remote_state
*rs
= get_remote_state ();
3203 if (rs
->use_threadinfo_query
)
3207 putpkt ("qfThreadInfo");
3208 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3210 if (bufp
[0] != '\0') /* q packet recognized */
3212 while (*bufp
++ == 'm') /* reply contains one or more TID */
3216 struct thread_item item
;
3218 item
.ptid
= read_ptid (bufp
, &bufp
);
3223 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3225 while (*bufp
++ == ','); /* comma-separated list */
3226 putpkt ("qsThreadInfo");
3227 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3234 /* Packet not recognized. */
3235 rs
->use_threadinfo_query
= 0;
3242 /* Implement the to_update_thread_list function for the remote
3246 remote_update_thread_list (struct target_ops
*ops
)
3248 struct threads_listing_context context
;
3249 struct cleanup
*old_chain
;
3252 context
.items
= NULL
;
3253 old_chain
= make_cleanup (clear_threads_listing_context
, &context
);
3255 /* We have a few different mechanisms to fetch the thread list. Try
3256 them all, starting with the most preferred one first, falling
3257 back to older methods. */
3258 if (remote_get_threads_with_qxfer (ops
, &context
)
3259 || remote_get_threads_with_qthreadinfo (ops
, &context
)
3260 || remote_get_threads_with_ql (ops
, &context
))
3263 struct thread_item
*item
;
3264 struct thread_info
*tp
, *tmp
;
3268 if (VEC_empty (thread_item_t
, context
.items
)
3269 && remote_thread_always_alive (ops
, inferior_ptid
))
3271 /* Some targets don't really support threads, but still
3272 reply an (empty) thread list in response to the thread
3273 listing packets, instead of replying "packet not
3274 supported". Exit early so we don't delete the main
3276 do_cleanups (old_chain
);
3280 /* CONTEXT now holds the current thread list on the remote
3281 target end. Delete GDB-side threads no longer found on the
3283 ALL_THREADS_SAFE (tp
, tmp
)
3286 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3289 if (ptid_equal (item
->ptid
, tp
->ptid
))
3293 if (i
== VEC_length (thread_item_t
, context
.items
))
3296 delete_thread (tp
->ptid
);
3300 /* Remove any unreported fork child threads from CONTEXT so
3301 that we don't interfere with follow fork, which is where
3302 creation of such threads is handled. */
3303 remove_new_fork_children (&context
);
3305 /* And now add threads we don't know about yet to our list. */
3307 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3310 if (!ptid_equal (item
->ptid
, null_ptid
))
3312 struct private_thread_info
*info
;
3313 /* In non-stop mode, we assume new found threads are
3314 executing until proven otherwise with a stop reply.
3315 In all-stop, we can only get here if all threads are
3317 int executing
= target_is_non_stop_p () ? 1 : 0;
3319 remote_notice_new_inferior (item
->ptid
, executing
);
3321 info
= get_private_info_ptid (item
->ptid
);
3322 info
->core
= item
->core
;
3323 info
->extra
= item
->extra
;
3325 info
->name
= item
->name
;
3333 /* If no thread listing method is supported, then query whether
3334 each known thread is alive, one by one, with the T packet.
3335 If the target doesn't support threads at all, then this is a
3336 no-op. See remote_thread_alive. */
3340 do_cleanups (old_chain
);
3344 * Collect a descriptive string about the given thread.
3345 * The target may say anything it wants to about the thread
3346 * (typically info about its blocked / runnable state, name, etc.).
3347 * This string will appear in the info threads display.
3349 * Optional: targets are not required to implement this function.
3353 remote_threads_extra_info (struct target_ops
*self
, struct thread_info
*tp
)
3355 struct remote_state
*rs
= get_remote_state ();
3359 struct gdb_ext_thread_info threadinfo
;
3360 static char display_buf
[100]; /* arbitrary... */
3361 int n
= 0; /* position in display_buf */
3363 if (rs
->remote_desc
== 0) /* paranoia */
3364 internal_error (__FILE__
, __LINE__
,
3365 _("remote_threads_extra_info"));
3367 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
3368 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_lwp (tp
->ptid
) == 0))
3369 /* This is the main thread which was added by GDB. The remote
3370 server doesn't know about it. */
3373 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3375 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
3377 if (info
&& info
->priv
)
3378 return info
->priv
->extra
;
3383 if (rs
->use_threadextra_query
)
3386 char *endb
= rs
->buf
+ get_remote_packet_size ();
3388 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3390 write_ptid (b
, endb
, tp
->ptid
);
3393 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3394 if (rs
->buf
[0] != 0)
3396 n
= std::min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
3397 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
3398 display_buf
[result
] = '\0';
3403 /* If the above query fails, fall back to the old method. */
3404 rs
->use_threadextra_query
= 0;
3405 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3406 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3407 int_to_threadref (&id
, ptid_get_lwp (tp
->ptid
));
3408 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3409 if (threadinfo
.active
)
3411 if (*threadinfo
.shortname
)
3412 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
3413 " Name: %s,", threadinfo
.shortname
);
3414 if (*threadinfo
.display
)
3415 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3416 " State: %s,", threadinfo
.display
);
3417 if (*threadinfo
.more_display
)
3418 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3419 " Priority: %s", threadinfo
.more_display
);
3423 /* For purely cosmetic reasons, clear up trailing commas. */
3424 if (',' == display_buf
[n
-1])
3425 display_buf
[n
-1] = ' ';
3434 remote_static_tracepoint_marker_at (struct target_ops
*self
, CORE_ADDR addr
,
3435 struct static_tracepoint_marker
*marker
)
3437 struct remote_state
*rs
= get_remote_state ();
3440 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3442 p
+= hexnumstr (p
, addr
);
3444 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3448 error (_("Remote failure reply: %s"), p
);
3452 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3459 static VEC(static_tracepoint_marker_p
) *
3460 remote_static_tracepoint_markers_by_strid (struct target_ops
*self
,
3463 struct remote_state
*rs
= get_remote_state ();
3464 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
3465 struct static_tracepoint_marker
*marker
= NULL
;
3466 struct cleanup
*old_chain
;
3469 /* Ask for a first packet of static tracepoint marker
3472 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3475 error (_("Remote failure reply: %s"), p
);
3477 old_chain
= make_cleanup (free_current_marker
, &marker
);
3482 marker
= XCNEW (struct static_tracepoint_marker
);
3486 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3488 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
3490 VEC_safe_push (static_tracepoint_marker_p
,
3496 release_static_tracepoint_marker (marker
);
3497 memset (marker
, 0, sizeof (*marker
));
3500 while (*p
++ == ','); /* comma-separated list */
3501 /* Ask for another packet of static tracepoint definition. */
3503 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3507 do_cleanups (old_chain
);
3512 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3515 remote_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
3517 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
3521 /* Restart the remote side; this is an extended protocol operation. */
3524 extended_remote_restart (void)
3526 struct remote_state
*rs
= get_remote_state ();
3528 /* Send the restart command; for reasons I don't understand the
3529 remote side really expects a number after the "R". */
3530 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
3533 remote_fileio_reset ();
3536 /* Clean up connection to a remote debugger. */
3539 remote_close (struct target_ops
*self
)
3541 struct remote_state
*rs
= get_remote_state ();
3543 if (rs
->remote_desc
== NULL
)
3544 return; /* already closed */
3546 /* Make sure we leave stdin registered in the event loop. */
3547 remote_terminal_ours (self
);
3549 serial_close (rs
->remote_desc
);
3550 rs
->remote_desc
= NULL
;
3552 /* We don't have a connection to the remote stub anymore. Get rid
3553 of all the inferiors and their threads we were controlling.
3554 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3555 will be unable to find the thread corresponding to (pid, 0, 0). */
3556 inferior_ptid
= null_ptid
;
3557 discard_all_inferiors ();
3559 /* We are closing the remote target, so we should discard
3560 everything of this target. */
3561 discard_pending_stop_replies_in_queue (rs
);
3563 if (remote_async_inferior_event_token
)
3564 delete_async_event_handler (&remote_async_inferior_event_token
);
3566 remote_notif_state_xfree (rs
->notif_state
);
3568 trace_reset_local_state ();
3571 /* Query the remote side for the text, data and bss offsets. */
3576 struct remote_state
*rs
= get_remote_state ();
3579 int lose
, num_segments
= 0, do_sections
, do_segments
;
3580 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
3581 struct section_offsets
*offs
;
3582 struct symfile_segment_data
*data
;
3584 if (symfile_objfile
== NULL
)
3587 putpkt ("qOffsets");
3588 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3591 if (buf
[0] == '\000')
3592 return; /* Return silently. Stub doesn't support
3596 warning (_("Remote failure reply: %s"), buf
);
3600 /* Pick up each field in turn. This used to be done with scanf, but
3601 scanf will make trouble if CORE_ADDR size doesn't match
3602 conversion directives correctly. The following code will work
3603 with any size of CORE_ADDR. */
3604 text_addr
= data_addr
= bss_addr
= 0;
3608 if (startswith (ptr
, "Text="))
3611 /* Don't use strtol, could lose on big values. */
3612 while (*ptr
&& *ptr
!= ';')
3613 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3615 if (startswith (ptr
, ";Data="))
3618 while (*ptr
&& *ptr
!= ';')
3619 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3624 if (!lose
&& startswith (ptr
, ";Bss="))
3627 while (*ptr
&& *ptr
!= ';')
3628 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
3630 if (bss_addr
!= data_addr
)
3631 warning (_("Target reported unsupported offsets: %s"), buf
);
3636 else if (startswith (ptr
, "TextSeg="))
3639 /* Don't use strtol, could lose on big values. */
3640 while (*ptr
&& *ptr
!= ';')
3641 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3644 if (startswith (ptr
, ";DataSeg="))
3647 while (*ptr
&& *ptr
!= ';')
3648 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3656 error (_("Malformed response to offset query, %s"), buf
);
3657 else if (*ptr
!= '\0')
3658 warning (_("Target reported unsupported offsets: %s"), buf
);
3660 offs
= ((struct section_offsets
*)
3661 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
3662 memcpy (offs
, symfile_objfile
->section_offsets
,
3663 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
3665 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
3666 do_segments
= (data
!= NULL
);
3667 do_sections
= num_segments
== 0;
3669 if (num_segments
> 0)
3671 segments
[0] = text_addr
;
3672 segments
[1] = data_addr
;
3674 /* If we have two segments, we can still try to relocate everything
3675 by assuming that the .text and .data offsets apply to the whole
3676 text and data segments. Convert the offsets given in the packet
3677 to base addresses for symfile_map_offsets_to_segments. */
3678 else if (data
&& data
->num_segments
== 2)
3680 segments
[0] = data
->segment_bases
[0] + text_addr
;
3681 segments
[1] = data
->segment_bases
[1] + data_addr
;
3684 /* If the object file has only one segment, assume that it is text
3685 rather than data; main programs with no writable data are rare,
3686 but programs with no code are useless. Of course the code might
3687 have ended up in the data segment... to detect that we would need
3688 the permissions here. */
3689 else if (data
&& data
->num_segments
== 1)
3691 segments
[0] = data
->segment_bases
[0] + text_addr
;
3694 /* There's no way to relocate by segment. */
3700 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
3701 offs
, num_segments
, segments
);
3703 if (ret
== 0 && !do_sections
)
3704 error (_("Can not handle qOffsets TextSeg "
3705 "response with this symbol file"));
3712 free_symfile_segment_data (data
);
3716 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
3718 /* This is a temporary kludge to force data and bss to use the
3719 same offsets because that's what nlmconv does now. The real
3720 solution requires changes to the stub and remote.c that I
3721 don't have time to do right now. */
3723 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
3724 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
3727 objfile_relocate (symfile_objfile
, offs
);
3730 /* Send interrupt_sequence to remote target. */
3732 send_interrupt_sequence (void)
3734 struct remote_state
*rs
= get_remote_state ();
3736 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
3737 remote_serial_write ("\x03", 1);
3738 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
3739 serial_send_break (rs
->remote_desc
);
3740 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
3742 serial_send_break (rs
->remote_desc
);
3743 remote_serial_write ("g", 1);
3746 internal_error (__FILE__
, __LINE__
,
3747 _("Invalid value for interrupt_sequence_mode: %s."),
3748 interrupt_sequence_mode
);
3752 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3753 and extract the PTID. Returns NULL_PTID if not found. */
3756 stop_reply_extract_thread (char *stop_reply
)
3758 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
3762 /* Txx r:val ; r:val (...) */
3765 /* Look for "register" named "thread". */
3770 p1
= strchr (p
, ':');
3774 if (strncmp (p
, "thread", p1
- p
) == 0)
3775 return read_ptid (++p1
, &p
);
3777 p1
= strchr (p
, ';');
3789 /* Determine the remote side's current thread. If we have a stop
3790 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3791 "thread" register we can extract the current thread from. If not,
3792 ask the remote which is the current thread with qC. The former
3793 method avoids a roundtrip. */
3796 get_current_thread (char *wait_status
)
3798 ptid_t ptid
= null_ptid
;
3800 /* Note we don't use remote_parse_stop_reply as that makes use of
3801 the target architecture, which we haven't yet fully determined at
3803 if (wait_status
!= NULL
)
3804 ptid
= stop_reply_extract_thread (wait_status
);
3805 if (ptid_equal (ptid
, null_ptid
))
3806 ptid
= remote_current_thread (inferior_ptid
);
3811 /* Query the remote target for which is the current thread/process,
3812 add it to our tables, and update INFERIOR_PTID. The caller is
3813 responsible for setting the state such that the remote end is ready
3814 to return the current thread.
3816 This function is called after handling the '?' or 'vRun' packets,
3817 whose response is a stop reply from which we can also try
3818 extracting the thread. If the target doesn't support the explicit
3819 qC query, we infer the current thread from that stop reply, passed
3820 in in WAIT_STATUS, which may be NULL. */
3823 add_current_inferior_and_thread (char *wait_status
)
3825 struct remote_state
*rs
= get_remote_state ();
3829 inferior_ptid
= null_ptid
;
3831 /* Now, if we have thread information, update inferior_ptid. */
3832 ptid
= get_current_thread (wait_status
);
3834 if (!ptid_equal (ptid
, null_ptid
))
3836 if (!remote_multi_process_p (rs
))
3839 inferior_ptid
= ptid
;
3843 /* Without this, some commands which require an active target
3844 (such as kill) won't work. This variable serves (at least)
3845 double duty as both the pid of the target process (if it has
3846 such), and as a flag indicating that a target is active. */
3847 inferior_ptid
= magic_null_ptid
;
3851 remote_add_inferior (fake_pid_p
, ptid_get_pid (inferior_ptid
), -1, 1);
3853 /* Add the main thread. */
3854 add_thread_silent (inferior_ptid
);
3857 /* Print info about a thread that was found already stopped on
3861 print_one_stopped_thread (struct thread_info
*thread
)
3863 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
3865 switch_to_thread (thread
->ptid
);
3866 stop_pc
= get_frame_pc (get_current_frame ());
3867 set_current_sal_from_frame (get_current_frame ());
3869 thread
->suspend
.waitstatus_pending_p
= 0;
3871 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
3873 enum gdb_signal sig
= ws
->value
.sig
;
3875 if (signal_print_state (sig
))
3876 observer_notify_signal_received (sig
);
3878 observer_notify_normal_stop (NULL
, 1);
3881 /* Process all initial stop replies the remote side sent in response
3882 to the ? packet. These indicate threads that were already stopped
3883 on initial connection. We mark these threads as stopped and print
3884 their current frame before giving the user the prompt. */
3887 process_initial_stop_replies (int from_tty
)
3889 int pending_stop_replies
= stop_reply_queue_length ();
3890 struct inferior
*inf
;
3891 struct thread_info
*thread
;
3892 struct thread_info
*selected
= NULL
;
3893 struct thread_info
*lowest_stopped
= NULL
;
3894 struct thread_info
*first
= NULL
;
3896 /* Consume the initial pending events. */
3897 while (pending_stop_replies
-- > 0)
3899 ptid_t waiton_ptid
= minus_one_ptid
;
3901 struct target_waitstatus ws
;
3902 int ignore_event
= 0;
3903 struct thread_info
*thread
;
3905 memset (&ws
, 0, sizeof (ws
));
3906 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
3908 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
3912 case TARGET_WAITKIND_IGNORE
:
3913 case TARGET_WAITKIND_NO_RESUMED
:
3914 case TARGET_WAITKIND_SIGNALLED
:
3915 case TARGET_WAITKIND_EXITED
:
3916 /* We shouldn't see these, but if we do, just ignore. */
3918 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
3922 case TARGET_WAITKIND_EXECD
:
3923 xfree (ws
.value
.execd_pathname
);
3932 thread
= find_thread_ptid (event_ptid
);
3934 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
3936 enum gdb_signal sig
= ws
.value
.sig
;
3938 /* Stubs traditionally report SIGTRAP as initial signal,
3939 instead of signal 0. Suppress it. */
3940 if (sig
== GDB_SIGNAL_TRAP
)
3942 thread
->suspend
.stop_signal
= sig
;
3946 thread
->suspend
.waitstatus
= ws
;
3948 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
3949 || ws
.value
.sig
!= GDB_SIGNAL_0
)
3950 thread
->suspend
.waitstatus_pending_p
= 1;
3952 set_executing (event_ptid
, 0);
3953 set_running (event_ptid
, 0);
3954 thread
->priv
->vcont_resumed
= 0;
3957 /* "Notice" the new inferiors before anything related to
3958 registers/memory. */
3964 inf
->needs_setup
= 1;
3968 thread
= any_live_thread_of_process (inf
->pid
);
3969 notice_new_inferior (thread
->ptid
,
3970 thread
->state
== THREAD_RUNNING
,
3975 /* If all-stop on top of non-stop, pause all threads. Note this
3976 records the threads' stop pc, so must be done after "noticing"
3980 stop_all_threads ();
3982 /* If all threads of an inferior were already stopped, we
3983 haven't setup the inferior yet. */
3989 if (inf
->needs_setup
)
3991 thread
= any_live_thread_of_process (inf
->pid
);
3992 switch_to_thread_no_regs (thread
);
3998 /* Now go over all threads that are stopped, and print their current
3999 frame. If all-stop, then if there's a signalled thread, pick
4001 ALL_NON_EXITED_THREADS (thread
)
4007 set_running (thread
->ptid
, 0);
4008 else if (thread
->state
!= THREAD_STOPPED
)
4011 if (selected
== NULL
4012 && thread
->suspend
.waitstatus_pending_p
)
4015 if (lowest_stopped
== NULL
4016 || thread
->inf
->num
< lowest_stopped
->inf
->num
4017 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4018 lowest_stopped
= thread
;
4021 print_one_stopped_thread (thread
);
4024 /* In all-stop, we only print the status of one thread, and leave
4025 others with their status pending. */
4030 thread
= lowest_stopped
;
4034 print_one_stopped_thread (thread
);
4037 /* For "info program". */
4038 thread
= inferior_thread ();
4039 if (thread
->state
== THREAD_STOPPED
)
4040 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4043 /* Start the remote connection and sync state. */
4046 remote_start_remote (int from_tty
, struct target_ops
*target
, int extended_p
)
4048 struct remote_state
*rs
= get_remote_state ();
4049 struct packet_config
*noack_config
;
4050 char *wait_status
= NULL
;
4052 /* Signal other parts that we're going through the initial setup,
4053 and so things may not be stable yet. E.g., we don't try to
4054 install tracepoints until we've relocated symbols. Also, a
4055 Ctrl-C before we're connected and synced up can't interrupt the
4056 target. Instead, it offers to drop the (potentially wedged)
4058 rs
->starting_up
= 1;
4062 if (interrupt_on_connect
)
4063 send_interrupt_sequence ();
4065 /* Ack any packet which the remote side has already sent. */
4066 remote_serial_write ("+", 1);
4068 /* The first packet we send to the target is the optional "supported
4069 packets" request. If the target can answer this, it will tell us
4070 which later probes to skip. */
4071 remote_query_supported ();
4073 /* If the stub wants to get a QAllow, compose one and send it. */
4074 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4075 remote_set_permissions (target
);
4077 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4078 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4079 as a reply to known packet. For packet "vFile:setfs:" it is an
4080 invalid reply and GDB would return error in
4081 remote_hostio_set_filesystem, making remote files access impossible.
4082 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4083 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4085 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4087 putpkt (v_mustreplyempty
);
4088 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4089 if (strcmp (rs
->buf
, "OK") == 0)
4090 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4091 else if (strcmp (rs
->buf
, "") != 0)
4092 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4096 /* Next, we possibly activate noack mode.
4098 If the QStartNoAckMode packet configuration is set to AUTO,
4099 enable noack mode if the stub reported a wish for it with
4102 If set to TRUE, then enable noack mode even if the stub didn't
4103 report it in qSupported. If the stub doesn't reply OK, the
4104 session ends with an error.
4106 If FALSE, then don't activate noack mode, regardless of what the
4107 stub claimed should be the default with qSupported. */
4109 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4110 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4112 putpkt ("QStartNoAckMode");
4113 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4114 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4120 /* Tell the remote that we are using the extended protocol. */
4122 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4125 /* Let the target know which signals it is allowed to pass down to
4127 update_signals_program_target ();
4129 /* Next, if the target can specify a description, read it. We do
4130 this before anything involving memory or registers. */
4131 target_find_description ();
4133 /* Next, now that we know something about the target, update the
4134 address spaces in the program spaces. */
4135 update_address_spaces ();
4137 /* On OSs where the list of libraries is global to all
4138 processes, we fetch them early. */
4139 if (gdbarch_has_global_solist (target_gdbarch ()))
4140 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
4142 if (target_is_non_stop_p ())
4144 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4145 error (_("Non-stop mode requested, but remote "
4146 "does not support non-stop"));
4148 putpkt ("QNonStop:1");
4149 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4151 if (strcmp (rs
->buf
, "OK") != 0)
4152 error (_("Remote refused setting non-stop mode with: %s"), rs
->buf
);
4154 /* Find about threads and processes the stub is already
4155 controlling. We default to adding them in the running state.
4156 The '?' query below will then tell us about which threads are
4158 remote_update_thread_list (target
);
4160 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4162 /* Don't assume that the stub can operate in all-stop mode.
4163 Request it explicitly. */
4164 putpkt ("QNonStop:0");
4165 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4167 if (strcmp (rs
->buf
, "OK") != 0)
4168 error (_("Remote refused setting all-stop mode with: %s"), rs
->buf
);
4171 /* Upload TSVs regardless of whether the target is running or not. The
4172 remote stub, such as GDBserver, may have some predefined or builtin
4173 TSVs, even if the target is not running. */
4174 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4176 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4178 remote_upload_trace_state_variables (target
, &uploaded_tsvs
);
4179 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4182 /* Check whether the target is running now. */
4184 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4186 if (!target_is_non_stop_p ())
4188 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4191 error (_("The target is not running (try extended-remote?)"));
4193 /* We're connected, but not running. Drop out before we
4194 call start_remote. */
4195 rs
->starting_up
= 0;
4200 /* Save the reply for later. */
4201 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
4202 strcpy (wait_status
, rs
->buf
);
4205 /* Fetch thread list. */
4206 target_update_thread_list ();
4208 /* Let the stub know that we want it to return the thread. */
4209 set_continue_thread (minus_one_ptid
);
4211 if (thread_count () == 0)
4213 /* Target has no concept of threads at all. GDB treats
4214 non-threaded target as single-threaded; add a main
4216 add_current_inferior_and_thread (wait_status
);
4220 /* We have thread information; select the thread the target
4221 says should be current. If we're reconnecting to a
4222 multi-threaded program, this will ideally be the thread
4223 that last reported an event before GDB disconnected. */
4224 inferior_ptid
= get_current_thread (wait_status
);
4225 if (ptid_equal (inferior_ptid
, null_ptid
))
4227 /* Odd... The target was able to list threads, but not
4228 tell us which thread was current (no "thread"
4229 register in T stop reply?). Just pick the first
4230 thread in the thread list then. */
4233 fprintf_unfiltered (gdb_stdlog
,
4234 "warning: couldn't determine remote "
4235 "current thread; picking first in list.\n");
4237 inferior_ptid
= thread_list
->ptid
;
4241 /* init_wait_for_inferior should be called before get_offsets in order
4242 to manage `inserted' flag in bp loc in a correct state.
4243 breakpoint_init_inferior, called from init_wait_for_inferior, set
4244 `inserted' flag to 0, while before breakpoint_re_set, called from
4245 start_remote, set `inserted' flag to 1. In the initialization of
4246 inferior, breakpoint_init_inferior should be called first, and then
4247 breakpoint_re_set can be called. If this order is broken, state of
4248 `inserted' flag is wrong, and cause some problems on breakpoint
4250 init_wait_for_inferior ();
4252 get_offsets (); /* Get text, data & bss offsets. */
4254 /* If we could not find a description using qXfer, and we know
4255 how to do it some other way, try again. This is not
4256 supported for non-stop; it could be, but it is tricky if
4257 there are no stopped threads when we connect. */
4258 if (remote_read_description_p (target
)
4259 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4261 target_clear_description ();
4262 target_find_description ();
4265 /* Use the previously fetched status. */
4266 gdb_assert (wait_status
!= NULL
);
4267 strcpy (rs
->buf
, wait_status
);
4268 rs
->cached_wait_status
= 1;
4270 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4274 /* Clear WFI global state. Do this before finding about new
4275 threads and inferiors, and setting the current inferior.
4276 Otherwise we would clear the proceed status of the current
4277 inferior when we want its stop_soon state to be preserved
4278 (see notice_new_inferior). */
4279 init_wait_for_inferior ();
4281 /* In non-stop, we will either get an "OK", meaning that there
4282 are no stopped threads at this time; or, a regular stop
4283 reply. In the latter case, there may be more than one thread
4284 stopped --- we pull them all out using the vStopped
4286 if (strcmp (rs
->buf
, "OK") != 0)
4288 struct notif_client
*notif
= ¬if_client_stop
;
4290 /* remote_notif_get_pending_replies acks this one, and gets
4292 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4293 = remote_notif_parse (notif
, rs
->buf
);
4294 remote_notif_get_pending_events (notif
);
4297 if (thread_count () == 0)
4300 error (_("The target is not running (try extended-remote?)"));
4302 /* We're connected, but not running. Drop out before we
4303 call start_remote. */
4304 rs
->starting_up
= 0;
4308 /* In non-stop mode, any cached wait status will be stored in
4309 the stop reply queue. */
4310 gdb_assert (wait_status
== NULL
);
4312 /* Report all signals during attach/startup. */
4313 remote_pass_signals (target
, 0, NULL
);
4315 /* If there are already stopped threads, mark them stopped and
4316 report their stops before giving the prompt to the user. */
4317 process_initial_stop_replies (from_tty
);
4319 if (target_can_async_p ())
4323 /* If we connected to a live target, do some additional setup. */
4324 if (target_has_execution
)
4326 if (symfile_objfile
) /* No use without a symbol-file. */
4327 remote_check_symbols ();
4330 /* Possibly the target has been engaged in a trace run started
4331 previously; find out where things are at. */
4332 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4334 struct uploaded_tp
*uploaded_tps
= NULL
;
4336 if (current_trace_status ()->running
)
4337 printf_filtered (_("Trace is already running on the target.\n"));
4339 remote_upload_tracepoints (target
, &uploaded_tps
);
4341 merge_uploaded_tracepoints (&uploaded_tps
);
4344 /* Possibly the target has been engaged in a btrace record started
4345 previously; find out where things are at. */
4346 remote_btrace_maybe_reopen ();
4348 /* The thread and inferior lists are now synchronized with the
4349 target, our symbols have been relocated, and we're merged the
4350 target's tracepoints with ours. We're done with basic start
4352 rs
->starting_up
= 0;
4354 /* Maybe breakpoints are global and need to be inserted now. */
4355 if (breakpoints_should_be_inserted_now ())
4356 insert_breakpoints ();
4359 /* Open a connection to a remote debugger.
4360 NAME is the filename used for communication. */
4363 remote_open (const char *name
, int from_tty
)
4365 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
4368 /* Open a connection to a remote debugger using the extended
4369 remote gdb protocol. NAME is the filename used for communication. */
4372 extended_remote_open (const char *name
, int from_tty
)
4374 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
4377 /* Reset all packets back to "unknown support". Called when opening a
4378 new connection to a remote target. */
4381 reset_all_packet_configs_support (void)
4385 for (i
= 0; i
< PACKET_MAX
; i
++)
4386 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4389 /* Initialize all packet configs. */
4392 init_all_packet_configs (void)
4396 for (i
= 0; i
< PACKET_MAX
; i
++)
4398 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4399 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4403 /* Symbol look-up. */
4406 remote_check_symbols (void)
4408 struct remote_state
*rs
= get_remote_state ();
4409 char *msg
, *reply
, *tmp
;
4412 struct cleanup
*old_chain
;
4414 /* The remote side has no concept of inferiors that aren't running
4415 yet, it only knows about running processes. If we're connected
4416 but our current inferior is not running, we should not invite the
4417 remote target to request symbol lookups related to its
4418 (unrelated) current process. */
4419 if (!target_has_execution
)
4422 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4425 /* Make sure the remote is pointing at the right process. Note
4426 there's no way to select "no process". */
4427 set_general_process ();
4429 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4430 because we need both at the same time. */
4431 msg
= (char *) xmalloc (get_remote_packet_size ());
4432 old_chain
= make_cleanup (xfree
, msg
);
4433 reply
= (char *) xmalloc (get_remote_packet_size ());
4434 make_cleanup (free_current_contents
, &reply
);
4435 reply_size
= get_remote_packet_size ();
4437 /* Invite target to request symbol lookups. */
4439 putpkt ("qSymbol::");
4440 getpkt (&reply
, &reply_size
, 0);
4441 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4443 while (startswith (reply
, "qSymbol:"))
4445 struct bound_minimal_symbol sym
;
4448 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
4450 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
4451 if (sym
.minsym
== NULL
)
4452 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
4455 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4456 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4458 /* If this is a function address, return the start of code
4459 instead of any data function descriptor. */
4460 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4464 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
4465 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4469 getpkt (&reply
, &reply_size
, 0);
4472 do_cleanups (old_chain
);
4475 static struct serial
*
4476 remote_serial_open (const char *name
)
4478 static int udp_warning
= 0;
4480 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4481 of in ser-tcp.c, because it is the remote protocol assuming that the
4482 serial connection is reliable and not the serial connection promising
4484 if (!udp_warning
&& startswith (name
, "udp:"))
4486 warning (_("The remote protocol may be unreliable over UDP.\n"
4487 "Some events may be lost, rendering further debugging "
4492 return serial_open (name
);
4495 /* Inform the target of our permission settings. The permission flags
4496 work without this, but if the target knows the settings, it can do
4497 a couple things. First, it can add its own check, to catch cases
4498 that somehow manage to get by the permissions checks in target
4499 methods. Second, if the target is wired to disallow particular
4500 settings (for instance, a system in the field that is not set up to
4501 be able to stop at a breakpoint), it can object to any unavailable
4505 remote_set_permissions (struct target_ops
*self
)
4507 struct remote_state
*rs
= get_remote_state ();
4509 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAllow:"
4510 "WriteReg:%x;WriteMem:%x;"
4511 "InsertBreak:%x;InsertTrace:%x;"
4512 "InsertFastTrace:%x;Stop:%x",
4513 may_write_registers
, may_write_memory
,
4514 may_insert_breakpoints
, may_insert_tracepoints
,
4515 may_insert_fast_tracepoints
, may_stop
);
4517 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4519 /* If the target didn't like the packet, warn the user. Do not try
4520 to undo the user's settings, that would just be maddening. */
4521 if (strcmp (rs
->buf
, "OK") != 0)
4522 warning (_("Remote refused setting permissions with: %s"), rs
->buf
);
4525 /* This type describes each known response to the qSupported
4527 struct protocol_feature
4529 /* The name of this protocol feature. */
4532 /* The default for this protocol feature. */
4533 enum packet_support default_support
;
4535 /* The function to call when this feature is reported, or after
4536 qSupported processing if the feature is not supported.
4537 The first argument points to this structure. The second
4538 argument indicates whether the packet requested support be
4539 enabled, disabled, or probed (or the default, if this function
4540 is being called at the end of processing and this feature was
4541 not reported). The third argument may be NULL; if not NULL, it
4542 is a NUL-terminated string taken from the packet following
4543 this feature's name and an equals sign. */
4544 void (*func
) (const struct protocol_feature
*, enum packet_support
,
4547 /* The corresponding packet for this feature. Only used if
4548 FUNC is remote_supported_packet. */
4553 remote_supported_packet (const struct protocol_feature
*feature
,
4554 enum packet_support support
,
4555 const char *argument
)
4559 warning (_("Remote qSupported response supplied an unexpected value for"
4560 " \"%s\"."), feature
->name
);
4564 remote_protocol_packets
[feature
->packet
].support
= support
;
4568 remote_packet_size (const struct protocol_feature
*feature
,
4569 enum packet_support support
, const char *value
)
4571 struct remote_state
*rs
= get_remote_state ();
4576 if (support
!= PACKET_ENABLE
)
4579 if (value
== NULL
|| *value
== '\0')
4581 warning (_("Remote target reported \"%s\" without a size."),
4587 packet_size
= strtol (value
, &value_end
, 16);
4588 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
4590 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4591 feature
->name
, value
);
4595 /* Record the new maximum packet size. */
4596 rs
->explicit_packet_size
= packet_size
;
4599 static const struct protocol_feature remote_protocol_features
[] = {
4600 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
4601 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
4602 PACKET_qXfer_auxv
},
4603 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
4604 PACKET_qXfer_exec_file
},
4605 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
4606 PACKET_qXfer_features
},
4607 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
4608 PACKET_qXfer_libraries
},
4609 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
4610 PACKET_qXfer_libraries_svr4
},
4611 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
4612 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
4613 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
4614 PACKET_qXfer_memory_map
},
4615 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
4616 PACKET_qXfer_spu_read
},
4617 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
4618 PACKET_qXfer_spu_write
},
4619 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
4620 PACKET_qXfer_osdata
},
4621 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
4622 PACKET_qXfer_threads
},
4623 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
4624 PACKET_qXfer_traceframe_info
},
4625 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
4626 PACKET_QPassSignals
},
4627 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
4628 PACKET_QCatchSyscalls
},
4629 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
4630 PACKET_QProgramSignals
},
4631 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
4632 PACKET_QStartNoAckMode
},
4633 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
4634 PACKET_multiprocess_feature
},
4635 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
4636 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
4637 PACKET_qXfer_siginfo_read
},
4638 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
4639 PACKET_qXfer_siginfo_write
},
4640 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4641 PACKET_ConditionalTracepoints
},
4642 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
4643 PACKET_ConditionalBreakpoints
},
4644 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
4645 PACKET_BreakpointCommands
},
4646 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4647 PACKET_FastTracepoints
},
4648 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4649 PACKET_StaticTracepoints
},
4650 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
4651 PACKET_InstallInTrace
},
4652 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
4653 PACKET_DisconnectedTracing_feature
},
4654 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
4656 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
4658 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
4659 PACKET_TracepointSource
},
4660 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
4662 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4663 PACKET_EnableDisableTracepoints_feature
},
4664 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
4665 PACKET_qXfer_fdpic
},
4666 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
4668 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
4669 PACKET_QDisableRandomization
},
4670 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
4671 { "QTBuffer:size", PACKET_DISABLE
,
4672 remote_supported_packet
, PACKET_QTBuffer_size
},
4673 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
4674 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
4675 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
4676 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
4677 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
4678 PACKET_qXfer_btrace
},
4679 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
4680 PACKET_qXfer_btrace_conf
},
4681 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
4682 PACKET_Qbtrace_conf_bts_size
},
4683 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
4684 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
4685 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
4686 PACKET_fork_event_feature
},
4687 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
4688 PACKET_vfork_event_feature
},
4689 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
4690 PACKET_exec_event_feature
},
4691 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
4692 PACKET_Qbtrace_conf_pt_size
},
4693 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
4694 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
4695 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
4698 static char *remote_support_xml
;
4700 /* Register string appended to "xmlRegisters=" in qSupported query. */
4703 register_remote_support_xml (const char *xml
)
4705 #if defined(HAVE_LIBEXPAT)
4706 if (remote_support_xml
== NULL
)
4707 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
4710 char *copy
= xstrdup (remote_support_xml
+ 13);
4711 char *p
= strtok (copy
, ",");
4715 if (strcmp (p
, xml
) == 0)
4722 while ((p
= strtok (NULL
, ",")) != NULL
);
4725 remote_support_xml
= reconcat (remote_support_xml
,
4726 remote_support_xml
, ",", xml
,
4733 remote_query_supported_append (char *msg
, const char *append
)
4736 return reconcat (msg
, msg
, ";", append
, (char *) NULL
);
4738 return xstrdup (append
);
4742 remote_query_supported (void)
4744 struct remote_state
*rs
= get_remote_state ();
4747 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
4749 /* The packet support flags are handled differently for this packet
4750 than for most others. We treat an error, a disabled packet, and
4751 an empty response identically: any features which must be reported
4752 to be used will be automatically disabled. An empty buffer
4753 accomplishes this, since that is also the representation for a list
4754 containing no features. */
4757 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
4760 struct cleanup
*old_chain
= make_cleanup (free_current_contents
, &q
);
4762 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
4763 q
= remote_query_supported_append (q
, "multiprocess+");
4765 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4766 q
= remote_query_supported_append (q
, "swbreak+");
4767 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4768 q
= remote_query_supported_append (q
, "hwbreak+");
4770 q
= remote_query_supported_append (q
, "qRelocInsn+");
4772 if (packet_set_cmd_state (PACKET_fork_event_feature
)
4773 != AUTO_BOOLEAN_FALSE
)
4774 q
= remote_query_supported_append (q
, "fork-events+");
4775 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
4776 != AUTO_BOOLEAN_FALSE
)
4777 q
= remote_query_supported_append (q
, "vfork-events+");
4778 if (packet_set_cmd_state (PACKET_exec_event_feature
)
4779 != AUTO_BOOLEAN_FALSE
)
4780 q
= remote_query_supported_append (q
, "exec-events+");
4782 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
4783 q
= remote_query_supported_append (q
, "vContSupported+");
4785 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
4786 q
= remote_query_supported_append (q
, "QThreadEvents+");
4788 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
4789 q
= remote_query_supported_append (q
, "no-resumed+");
4791 /* Keep this one last to work around a gdbserver <= 7.10 bug in
4792 the qSupported:xmlRegisters=i386 handling. */
4793 if (remote_support_xml
!= NULL
)
4794 q
= remote_query_supported_append (q
, remote_support_xml
);
4796 q
= reconcat (q
, "qSupported:", q
, (char *) NULL
);
4799 do_cleanups (old_chain
);
4801 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4803 /* If an error occured, warn, but do not return - just reset the
4804 buffer to empty and go on to disable features. */
4805 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
4808 warning (_("Remote failure reply: %s"), rs
->buf
);
4813 memset (seen
, 0, sizeof (seen
));
4818 enum packet_support is_supported
;
4819 char *p
, *end
, *name_end
, *value
;
4821 /* First separate out this item from the rest of the packet. If
4822 there's another item after this, we overwrite the separator
4823 (terminated strings are much easier to work with). */
4825 end
= strchr (p
, ';');
4828 end
= p
+ strlen (p
);
4838 warning (_("empty item in \"qSupported\" response"));
4843 name_end
= strchr (p
, '=');
4846 /* This is a name=value entry. */
4847 is_supported
= PACKET_ENABLE
;
4848 value
= name_end
+ 1;
4857 is_supported
= PACKET_ENABLE
;
4861 is_supported
= PACKET_DISABLE
;
4865 is_supported
= PACKET_SUPPORT_UNKNOWN
;
4869 warning (_("unrecognized item \"%s\" "
4870 "in \"qSupported\" response"), p
);
4876 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4877 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
4879 const struct protocol_feature
*feature
;
4882 feature
= &remote_protocol_features
[i
];
4883 feature
->func (feature
, is_supported
, value
);
4888 /* If we increased the packet size, make sure to increase the global
4889 buffer size also. We delay this until after parsing the entire
4890 qSupported packet, because this is the same buffer we were
4892 if (rs
->buf_size
< rs
->explicit_packet_size
)
4894 rs
->buf_size
= rs
->explicit_packet_size
;
4895 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
4898 /* Handle the defaults for unmentioned features. */
4899 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4902 const struct protocol_feature
*feature
;
4904 feature
= &remote_protocol_features
[i
];
4905 feature
->func (feature
, feature
->default_support
, NULL
);
4909 /* Serial QUIT handler for the remote serial descriptor.
4911 Defers handling a Ctrl-C until we're done with the current
4912 command/response packet sequence, unless:
4914 - We're setting up the connection. Don't send a remote interrupt
4915 request, as we're not fully synced yet. Quit immediately
4918 - The target has been resumed in the foreground
4919 (target_terminal_is_ours is false) with a synchronous resume
4920 packet, and we're blocked waiting for the stop reply, thus a
4921 Ctrl-C should be immediately sent to the target.
4923 - We get a second Ctrl-C while still within the same serial read or
4924 write. In that case the serial is seemingly wedged --- offer to
4927 - We see a second Ctrl-C without target response, after having
4928 previously interrupted the target. In that case the target/stub
4929 is probably wedged --- offer to quit/disconnect.
4933 remote_serial_quit_handler (void)
4935 struct remote_state
*rs
= get_remote_state ();
4937 if (check_quit_flag ())
4939 /* If we're starting up, we're not fully synced yet. Quit
4941 if (rs
->starting_up
)
4943 else if (rs
->got_ctrlc_during_io
)
4945 if (query (_("The target is not responding to GDB commands.\n"
4946 "Stop debugging it? ")))
4947 remote_unpush_and_throw ();
4949 /* If ^C has already been sent once, offer to disconnect. */
4950 else if (!target_terminal_is_ours () && rs
->ctrlc_pending_p
)
4952 /* All-stop protocol, and blocked waiting for stop reply. Send
4953 an interrupt request. */
4954 else if (!target_terminal_is_ours () && rs
->waiting_for_stop_reply
)
4955 target_interrupt (inferior_ptid
);
4957 rs
->got_ctrlc_during_io
= 1;
4961 /* Remove any of the remote.c targets from target stack. Upper targets depend
4962 on it so remove them first. */
4965 remote_unpush_target (void)
4967 pop_all_targets_at_and_above (process_stratum
);
4971 remote_unpush_and_throw (void)
4973 remote_unpush_target ();
4974 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
4978 remote_open_1 (const char *name
, int from_tty
,
4979 struct target_ops
*target
, int extended_p
)
4981 struct remote_state
*rs
= get_remote_state ();
4984 error (_("To open a remote debug connection, you need to specify what\n"
4985 "serial device is attached to the remote system\n"
4986 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
4988 /* See FIXME above. */
4989 if (!target_async_permitted
)
4990 wait_forever_enabled_p
= 1;
4992 /* If we're connected to a running target, target_preopen will kill it.
4993 Ask this question first, before target_preopen has a chance to kill
4995 if (rs
->remote_desc
!= NULL
&& !have_inferiors ())
4998 && !query (_("Already connected to a remote target. Disconnect? ")))
4999 error (_("Still connected."));
5002 /* Here the possibly existing remote target gets unpushed. */
5003 target_preopen (from_tty
);
5005 /* Make sure we send the passed signals list the next time we resume. */
5006 xfree (rs
->last_pass_packet
);
5007 rs
->last_pass_packet
= NULL
;
5009 /* Make sure we send the program signals list the next time we
5011 xfree (rs
->last_program_signals_packet
);
5012 rs
->last_program_signals_packet
= NULL
;
5014 remote_fileio_reset ();
5015 reopen_exec_file ();
5018 rs
->remote_desc
= remote_serial_open (name
);
5019 if (!rs
->remote_desc
)
5020 perror_with_name (name
);
5022 if (baud_rate
!= -1)
5024 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5026 /* The requested speed could not be set. Error out to
5027 top level after closing remote_desc. Take care to
5028 set remote_desc to NULL to avoid closing remote_desc
5030 serial_close (rs
->remote_desc
);
5031 rs
->remote_desc
= NULL
;
5032 perror_with_name (name
);
5036 serial_setparity (rs
->remote_desc
, serial_parity
);
5037 serial_raw (rs
->remote_desc
);
5039 /* If there is something sitting in the buffer we might take it as a
5040 response to a command, which would be bad. */
5041 serial_flush_input (rs
->remote_desc
);
5045 puts_filtered ("Remote debugging using ");
5046 puts_filtered (name
);
5047 puts_filtered ("\n");
5049 push_target (target
); /* Switch to using remote target now. */
5051 /* Register extra event sources in the event loop. */
5052 remote_async_inferior_event_token
5053 = create_async_event_handler (remote_async_inferior_event_handler
,
5055 rs
->notif_state
= remote_notif_state_allocate ();
5057 /* Reset the target state; these things will be queried either by
5058 remote_query_supported or as they are needed. */
5059 reset_all_packet_configs_support ();
5060 rs
->cached_wait_status
= 0;
5061 rs
->explicit_packet_size
= 0;
5063 rs
->extended
= extended_p
;
5064 rs
->waiting_for_stop_reply
= 0;
5065 rs
->ctrlc_pending_p
= 0;
5066 rs
->got_ctrlc_during_io
= 0;
5068 rs
->general_thread
= not_sent_ptid
;
5069 rs
->continue_thread
= not_sent_ptid
;
5070 rs
->remote_traceframe_number
= -1;
5072 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5074 /* Probe for ability to use "ThreadInfo" query, as required. */
5075 rs
->use_threadinfo_query
= 1;
5076 rs
->use_threadextra_query
= 1;
5078 readahead_cache_invalidate ();
5080 /* Start out by owning the terminal. */
5081 remote_async_terminal_ours_p
= 1;
5083 if (target_async_permitted
)
5085 /* FIXME: cagney/1999-09-23: During the initial connection it is
5086 assumed that the target is already ready and able to respond to
5087 requests. Unfortunately remote_start_remote() eventually calls
5088 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5089 around this. Eventually a mechanism that allows
5090 wait_for_inferior() to expect/get timeouts will be
5092 wait_forever_enabled_p
= 0;
5095 /* First delete any symbols previously loaded from shared libraries. */
5096 no_shared_libraries (NULL
, 0);
5099 init_thread_list ();
5101 /* Start the remote connection. If error() or QUIT, discard this
5102 target (we'd otherwise be in an inconsistent state) and then
5103 propogate the error on up the exception chain. This ensures that
5104 the caller doesn't stumble along blindly assuming that the
5105 function succeeded. The CLI doesn't have this problem but other
5106 UI's, such as MI do.
5108 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5109 this function should return an error indication letting the
5110 caller restore the previous state. Unfortunately the command
5111 ``target remote'' is directly wired to this function making that
5112 impossible. On a positive note, the CLI side of this problem has
5113 been fixed - the function set_cmd_context() makes it possible for
5114 all the ``target ....'' commands to share a common callback
5115 function. See cli-dump.c. */
5120 remote_start_remote (from_tty
, target
, extended_p
);
5122 CATCH (ex
, RETURN_MASK_ALL
)
5124 /* Pop the partially set up target - unless something else did
5125 already before throwing the exception. */
5126 if (rs
->remote_desc
!= NULL
)
5127 remote_unpush_target ();
5128 if (target_async_permitted
)
5129 wait_forever_enabled_p
= 1;
5130 throw_exception (ex
);
5135 remote_btrace_reset ();
5137 if (target_async_permitted
)
5138 wait_forever_enabled_p
= 1;
5141 /* Detach the specified process. */
5144 remote_detach_pid (int pid
)
5146 struct remote_state
*rs
= get_remote_state ();
5148 if (remote_multi_process_p (rs
))
5149 xsnprintf (rs
->buf
, get_remote_packet_size (), "D;%x", pid
);
5151 strcpy (rs
->buf
, "D");
5154 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5156 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5158 else if (rs
->buf
[0] == '\0')
5159 error (_("Remote doesn't know how to detach"));
5161 error (_("Can't detach process."));
5164 /* This detaches a program to which we previously attached, using
5165 inferior_ptid to identify the process. After this is done, GDB
5166 can be used to debug some other program. We better not have left
5167 any breakpoints in the target program or it'll die when it hits
5171 remote_detach_1 (const char *args
, int from_tty
)
5173 int pid
= ptid_get_pid (inferior_ptid
);
5174 struct remote_state
*rs
= get_remote_state ();
5175 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5179 error (_("Argument given to \"detach\" when remotely debugging."));
5181 if (!target_has_execution
)
5182 error (_("No process to detach from."));
5184 target_announce_detach (from_tty
);
5186 /* Tell the remote target to detach. */
5187 remote_detach_pid (pid
);
5189 /* Exit only if this is the only active inferior. */
5190 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5191 puts_filtered (_("Ending remote debugging.\n"));
5193 /* Check to see if we are detaching a fork parent. Note that if we
5194 are detaching a fork child, tp == NULL. */
5195 is_fork_parent
= (tp
!= NULL
5196 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5198 /* If doing detach-on-fork, we don't mourn, because that will delete
5199 breakpoints that should be available for the followed inferior. */
5200 if (!is_fork_parent
)
5201 target_mourn_inferior (inferior_ptid
);
5204 inferior_ptid
= null_ptid
;
5205 detach_inferior (pid
);
5210 remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5212 remote_detach_1 (args
, from_tty
);
5216 extended_remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5218 remote_detach_1 (args
, from_tty
);
5221 /* Target follow-fork function for remote targets. On entry, and
5222 at return, the current inferior is the fork parent.
5224 Note that although this is currently only used for extended-remote,
5225 it is named remote_follow_fork in anticipation of using it for the
5226 remote target as well. */
5229 remote_follow_fork (struct target_ops
*ops
, int follow_child
,
5232 struct remote_state
*rs
= get_remote_state ();
5233 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5235 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5236 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5238 /* When following the parent and detaching the child, we detach
5239 the child here. For the case of following the child and
5240 detaching the parent, the detach is done in the target-
5241 independent follow fork code in infrun.c. We can't use
5242 target_detach when detaching an unfollowed child because
5243 the client side doesn't know anything about the child. */
5244 if (detach_fork
&& !follow_child
)
5246 /* Detach the fork child. */
5250 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5251 child_pid
= ptid_get_pid (child_ptid
);
5253 remote_detach_pid (child_pid
);
5254 detach_inferior (child_pid
);
5260 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5261 in the program space of the new inferior. On entry and at return the
5262 current inferior is the exec'ing inferior. INF is the new exec'd
5263 inferior, which may be the same as the exec'ing inferior unless
5264 follow-exec-mode is "new". */
5267 remote_follow_exec (struct target_ops
*ops
,
5268 struct inferior
*inf
, char *execd_pathname
)
5270 /* We know that this is a target file name, so if it has the "target:"
5271 prefix we strip it off before saving it in the program space. */
5272 if (is_target_filename (execd_pathname
))
5273 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5275 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5278 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5281 remote_disconnect (struct target_ops
*target
, const char *args
, int from_tty
)
5284 error (_("Argument given to \"disconnect\" when remotely debugging."));
5286 /* Make sure we unpush even the extended remote targets. Calling
5287 target_mourn_inferior won't unpush, and remote_mourn won't
5288 unpush if there is more than one inferior left. */
5289 unpush_target (target
);
5290 generic_mourn_inferior ();
5293 puts_filtered ("Ending remote debugging.\n");
5296 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5297 be chatty about it. */
5300 extended_remote_attach (struct target_ops
*target
, const char *args
,
5303 struct remote_state
*rs
= get_remote_state ();
5305 char *wait_status
= NULL
;
5307 pid
= parse_pid_to_attach (args
);
5309 /* Remote PID can be freely equal to getpid, do not check it here the same
5310 way as in other targets. */
5312 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5313 error (_("This target does not support attaching to a process"));
5317 char *exec_file
= get_exec_file (0);
5320 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5321 target_pid_to_str (pid_to_ptid (pid
)));
5323 printf_unfiltered (_("Attaching to %s\n"),
5324 target_pid_to_str (pid_to_ptid (pid
)));
5326 gdb_flush (gdb_stdout
);
5329 xsnprintf (rs
->buf
, get_remote_packet_size (), "vAttach;%x", pid
);
5331 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5333 switch (packet_ok (rs
->buf
,
5334 &remote_protocol_packets
[PACKET_vAttach
]))
5337 if (!target_is_non_stop_p ())
5339 /* Save the reply for later. */
5340 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
5341 strcpy (wait_status
, rs
->buf
);
5343 else if (strcmp (rs
->buf
, "OK") != 0)
5344 error (_("Attaching to %s failed with: %s"),
5345 target_pid_to_str (pid_to_ptid (pid
)),
5348 case PACKET_UNKNOWN
:
5349 error (_("This target does not support attaching to a process"));
5351 error (_("Attaching to %s failed"),
5352 target_pid_to_str (pid_to_ptid (pid
)));
5355 set_current_inferior (remote_add_inferior (0, pid
, 1, 0));
5357 inferior_ptid
= pid_to_ptid (pid
);
5359 if (target_is_non_stop_p ())
5361 struct thread_info
*thread
;
5363 /* Get list of threads. */
5364 remote_update_thread_list (target
);
5366 thread
= first_thread_of_process (pid
);
5368 inferior_ptid
= thread
->ptid
;
5370 inferior_ptid
= pid_to_ptid (pid
);
5372 /* Invalidate our notion of the remote current thread. */
5373 record_currthread (rs
, minus_one_ptid
);
5377 /* Now, if we have thread information, update inferior_ptid. */
5378 inferior_ptid
= remote_current_thread (inferior_ptid
);
5380 /* Add the main thread to the thread list. */
5381 add_thread_silent (inferior_ptid
);
5384 /* Next, if the target can specify a description, read it. We do
5385 this before anything involving memory or registers. */
5386 target_find_description ();
5388 if (!target_is_non_stop_p ())
5390 /* Use the previously fetched status. */
5391 gdb_assert (wait_status
!= NULL
);
5393 if (target_can_async_p ())
5395 struct notif_event
*reply
5396 = remote_notif_parse (¬if_client_stop
, wait_status
);
5398 push_stop_reply ((struct stop_reply
*) reply
);
5404 gdb_assert (wait_status
!= NULL
);
5405 strcpy (rs
->buf
, wait_status
);
5406 rs
->cached_wait_status
= 1;
5410 gdb_assert (wait_status
== NULL
);
5413 /* Implementation of the to_post_attach method. */
5416 extended_remote_post_attach (struct target_ops
*ops
, int pid
)
5418 /* Get text, data & bss offsets. */
5421 /* In certain cases GDB might not have had the chance to start
5422 symbol lookup up until now. This could happen if the debugged
5423 binary is not using shared libraries, the vsyscall page is not
5424 present (on Linux) and the binary itself hadn't changed since the
5425 debugging process was started. */
5426 if (symfile_objfile
!= NULL
)
5427 remote_check_symbols();
5431 /* Check for the availability of vCont. This function should also check
5435 remote_vcont_probe (struct remote_state
*rs
)
5439 strcpy (rs
->buf
, "vCont?");
5441 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5444 /* Make sure that the features we assume are supported. */
5445 if (startswith (buf
, "vCont"))
5448 int support_c
, support_C
;
5450 rs
->supports_vCont
.s
= 0;
5451 rs
->supports_vCont
.S
= 0;
5454 rs
->supports_vCont
.t
= 0;
5455 rs
->supports_vCont
.r
= 0;
5456 while (p
&& *p
== ';')
5459 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5460 rs
->supports_vCont
.s
= 1;
5461 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5462 rs
->supports_vCont
.S
= 1;
5463 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5465 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5467 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5468 rs
->supports_vCont
.t
= 1;
5469 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5470 rs
->supports_vCont
.r
= 1;
5472 p
= strchr (p
, ';');
5475 /* If c, and C are not all supported, we can't use vCont. Clearing
5476 BUF will make packet_ok disable the packet. */
5477 if (!support_c
|| !support_C
)
5481 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
5484 /* Helper function for building "vCont" resumptions. Write a
5485 resumption to P. ENDP points to one-passed-the-end of the buffer
5486 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5487 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5488 resumed thread should be single-stepped and/or signalled. If PTID
5489 equals minus_one_ptid, then all threads are resumed; if PTID
5490 represents a process, then all threads of the process are resumed;
5491 the thread to be stepped and/or signalled is given in the global
5495 append_resumption (char *p
, char *endp
,
5496 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5498 struct remote_state
*rs
= get_remote_state ();
5500 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5501 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5503 /* GDB is willing to range step. */
5504 && use_range_stepping
5505 /* Target supports range stepping. */
5506 && rs
->supports_vCont
.r
5507 /* We don't currently support range stepping multiple
5508 threads with a wildcard (though the protocol allows it,
5509 so stubs shouldn't make an active effort to forbid
5511 && !(remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
5513 struct thread_info
*tp
;
5515 if (ptid_equal (ptid
, minus_one_ptid
))
5517 /* If we don't know about the target thread's tid, then
5518 we're resuming magic_null_ptid (see caller). */
5519 tp
= find_thread_ptid (magic_null_ptid
);
5522 tp
= find_thread_ptid (ptid
);
5523 gdb_assert (tp
!= NULL
);
5525 if (tp
->control
.may_range_step
)
5527 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5529 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
5530 phex_nz (tp
->control
.step_range_start
,
5532 phex_nz (tp
->control
.step_range_end
,
5536 p
+= xsnprintf (p
, endp
- p
, ";s");
5539 p
+= xsnprintf (p
, endp
- p
, ";s");
5540 else if (siggnal
!= GDB_SIGNAL_0
)
5541 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
5543 p
+= xsnprintf (p
, endp
- p
, ";c");
5545 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
5549 /* All (-1) threads of process. */
5550 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
5552 p
+= xsnprintf (p
, endp
- p
, ":");
5553 p
= write_ptid (p
, endp
, nptid
);
5555 else if (!ptid_equal (ptid
, minus_one_ptid
))
5557 p
+= xsnprintf (p
, endp
- p
, ":");
5558 p
= write_ptid (p
, endp
, ptid
);
5564 /* Clear the thread's private info on resume. */
5567 resume_clear_thread_private_info (struct thread_info
*thread
)
5569 if (thread
->priv
!= NULL
)
5571 thread
->priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
5572 thread
->priv
->watch_data_address
= 0;
5576 /* Append a vCont continue-with-signal action for threads that have a
5577 non-zero stop signal. */
5580 append_pending_thread_resumptions (char *p
, char *endp
, ptid_t ptid
)
5582 struct thread_info
*thread
;
5584 ALL_NON_EXITED_THREADS (thread
)
5585 if (ptid_match (thread
->ptid
, ptid
)
5586 && !ptid_equal (inferior_ptid
, thread
->ptid
)
5587 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
5589 p
= append_resumption (p
, endp
, thread
->ptid
,
5590 0, thread
->suspend
.stop_signal
);
5591 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5592 resume_clear_thread_private_info (thread
);
5598 /* Set the target running, using the packets that use Hc
5602 remote_resume_with_hc (struct target_ops
*ops
,
5603 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5605 struct remote_state
*rs
= get_remote_state ();
5606 struct thread_info
*thread
;
5609 rs
->last_sent_signal
= siggnal
;
5610 rs
->last_sent_step
= step
;
5612 /* The c/s/C/S resume packets use Hc, so set the continue
5614 if (ptid_equal (ptid
, minus_one_ptid
))
5615 set_continue_thread (any_thread_ptid
);
5617 set_continue_thread (ptid
);
5619 ALL_NON_EXITED_THREADS (thread
)
5620 resume_clear_thread_private_info (thread
);
5623 if (execution_direction
== EXEC_REVERSE
)
5625 /* We don't pass signals to the target in reverse exec mode. */
5626 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
5627 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5630 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
5631 error (_("Remote reverse-step not supported."));
5632 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
5633 error (_("Remote reverse-continue not supported."));
5635 strcpy (buf
, step
? "bs" : "bc");
5637 else if (siggnal
!= GDB_SIGNAL_0
)
5639 buf
[0] = step
? 'S' : 'C';
5640 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
5641 buf
[2] = tohex (((int) siggnal
) & 0xf);
5645 strcpy (buf
, step
? "s" : "c");
5650 /* Resume the remote inferior by using a "vCont" packet. The thread
5651 to be resumed is PTID; STEP and SIGGNAL indicate whether the
5652 resumed thread should be single-stepped and/or signalled. If PTID
5653 equals minus_one_ptid, then all threads are resumed; the thread to
5654 be stepped and/or signalled is given in the global INFERIOR_PTID.
5655 This function returns non-zero iff it resumes the inferior.
5657 This function issues a strict subset of all possible vCont commands
5661 remote_resume_with_vcont (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5663 struct remote_state
*rs
= get_remote_state ();
5667 /* No reverse execution actions defined for vCont. */
5668 if (execution_direction
== EXEC_REVERSE
)
5671 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
5672 remote_vcont_probe (rs
);
5674 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
5678 endp
= rs
->buf
+ get_remote_packet_size ();
5680 /* If we could generate a wider range of packets, we'd have to worry
5681 about overflowing BUF. Should there be a generic
5682 "multi-part-packet" packet? */
5684 p
+= xsnprintf (p
, endp
- p
, "vCont");
5686 if (ptid_equal (ptid
, magic_null_ptid
))
5688 /* MAGIC_NULL_PTID means that we don't have any active threads,
5689 so we don't have any TID numbers the inferior will
5690 understand. Make sure to only send forms that do not specify
5692 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
5694 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
5696 /* Resume all threads (of all processes, or of a single
5697 process), with preference for INFERIOR_PTID. This assumes
5698 inferior_ptid belongs to the set of all threads we are about
5700 if (step
|| siggnal
!= GDB_SIGNAL_0
)
5702 /* Step inferior_ptid, with or without signal. */
5703 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
5706 /* Also pass down any pending signaled resumption for other
5707 threads not the current. */
5708 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
5710 /* And continue others without a signal. */
5711 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
5715 /* Scheduler locking; resume only PTID. */
5716 append_resumption (p
, endp
, ptid
, step
, siggnal
);
5719 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
5722 if (target_is_non_stop_p ())
5724 /* In non-stop, the stub replies to vCont with "OK". The stop
5725 reply will be reported asynchronously by means of a `%Stop'
5727 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5728 if (strcmp (rs
->buf
, "OK") != 0)
5729 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5735 /* Tell the remote machine to resume. */
5738 remote_resume (struct target_ops
*ops
,
5739 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5741 struct remote_state
*rs
= get_remote_state ();
5743 /* When connected in non-stop mode, the core resumes threads
5744 individually. Resuming remote threads directly in target_resume
5745 would thus result in sending one packet per thread. Instead, to
5746 minimize roundtrip latency, here we just store the resume
5747 request; the actual remote resumption will be done in
5748 target_commit_resume / remote_commit_resume, where we'll be able
5749 to do vCont action coalescing. */
5750 if (target_is_non_stop_p () && execution_direction
!= EXEC_REVERSE
)
5752 struct private_thread_info
*remote_thr
;
5754 if (ptid_equal (minus_one_ptid
, ptid
) || ptid_is_pid (ptid
))
5755 remote_thr
= get_private_info_ptid (inferior_ptid
);
5757 remote_thr
= get_private_info_ptid (ptid
);
5758 remote_thr
->last_resume_step
= step
;
5759 remote_thr
->last_resume_sig
= siggnal
;
5763 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5764 (explained in remote-notif.c:handle_notification) so
5765 remote_notif_process is not called. We need find a place where
5766 it is safe to start a 'vNotif' sequence. It is good to do it
5767 before resuming inferior, because inferior was stopped and no RSP
5768 traffic at that moment. */
5769 if (!target_is_non_stop_p ())
5770 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
5772 rs
->last_resume_exec_dir
= execution_direction
;
5774 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
5775 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
5776 remote_resume_with_hc (ops
, ptid
, step
, siggnal
);
5778 /* We are about to start executing the inferior, let's register it
5779 with the event loop. NOTE: this is the one place where all the
5780 execution commands end up. We could alternatively do this in each
5781 of the execution commands in infcmd.c. */
5782 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5783 into infcmd.c in order to allow inferior function calls to work
5784 NOT asynchronously. */
5785 if (target_can_async_p ())
5788 /* We've just told the target to resume. The remote server will
5789 wait for the inferior to stop, and then send a stop reply. In
5790 the mean time, we can't start another command/query ourselves
5791 because the stub wouldn't be ready to process it. This applies
5792 only to the base all-stop protocol, however. In non-stop (which
5793 only supports vCont), the stub replies with an "OK", and is
5794 immediate able to process further serial input. */
5795 if (!target_is_non_stop_p ())
5796 rs
->waiting_for_stop_reply
= 1;
5799 static void check_pending_events_prevent_wildcard_vcont
5800 (int *may_global_wildcard_vcont
);
5801 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
5803 /* Private per-inferior info for target remote processes. */
5805 struct private_inferior
5807 /* Whether we can send a wildcard vCont for this process. */
5808 int may_wildcard_vcont
;
5811 /* Structure used to track the construction of a vCont packet in the
5812 outgoing packet buffer. This is used to send multiple vCont
5813 packets if we have more actions than would fit a single packet. */
5815 struct vcont_builder
5817 /* Pointer to the first action. P points here if no action has been
5821 /* Where the next action will be appended. */
5824 /* The end of the buffer. Must never write past this. */
5828 /* Prepare the outgoing buffer for a new vCont packet. */
5831 vcont_builder_restart (struct vcont_builder
*builder
)
5833 struct remote_state
*rs
= get_remote_state ();
5835 builder
->p
= rs
->buf
;
5836 builder
->endp
= rs
->buf
+ get_remote_packet_size ();
5837 builder
->p
+= xsnprintf (builder
->p
, builder
->endp
- builder
->p
, "vCont");
5838 builder
->first_action
= builder
->p
;
5841 /* If the vCont packet being built has any action, send it to the
5845 vcont_builder_flush (struct vcont_builder
*builder
)
5847 struct remote_state
*rs
;
5849 if (builder
->p
== builder
->first_action
)
5852 rs
= get_remote_state ();
5854 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5855 if (strcmp (rs
->buf
, "OK") != 0)
5856 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5859 /* The largest action is range-stepping, with its two addresses. This
5860 is more than sufficient. If a new, bigger action is created, it'll
5861 quickly trigger a failed assertion in append_resumption (and we'll
5863 #define MAX_ACTION_SIZE 200
5865 /* Append a new vCont action in the outgoing packet being built. If
5866 the action doesn't fit the packet along with previous actions, push
5867 what we've got so far to the remote end and start over a new vCont
5868 packet (with the new action). */
5871 vcont_builder_push_action (struct vcont_builder
*builder
,
5872 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5874 char buf
[MAX_ACTION_SIZE
+ 1];
5878 endp
= append_resumption (buf
, buf
+ sizeof (buf
),
5879 ptid
, step
, siggnal
);
5881 /* Check whether this new action would fit in the vCont packet along
5882 with previous actions. If not, send what we've got so far and
5883 start a new vCont packet. */
5885 if (rsize
> builder
->endp
- builder
->p
)
5887 vcont_builder_flush (builder
);
5888 vcont_builder_restart (builder
);
5890 /* Should now fit. */
5891 gdb_assert (rsize
<= builder
->endp
- builder
->p
);
5894 memcpy (builder
->p
, buf
, rsize
);
5895 builder
->p
+= rsize
;
5899 /* to_commit_resume implementation. */
5902 remote_commit_resume (struct target_ops
*ops
)
5904 struct remote_state
*rs
= get_remote_state ();
5905 struct inferior
*inf
;
5906 struct thread_info
*tp
;
5907 int any_process_wildcard
;
5908 int may_global_wildcard_vcont
;
5909 struct vcont_builder vcont_builder
;
5911 /* If connected in all-stop mode, we'd send the remote resume
5912 request directly from remote_resume. Likewise if
5913 reverse-debugging, as there are no defined vCont actions for
5914 reverse execution. */
5915 if (!target_is_non_stop_p () || execution_direction
== EXEC_REVERSE
)
5918 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
5919 instead of resuming all threads of each process individually.
5920 However, if any thread of a process must remain halted, we can't
5921 send wildcard resumes and must send one action per thread.
5923 Care must be taken to not resume threads/processes the server
5924 side already told us are stopped, but the core doesn't know about
5925 yet, because the events are still in the vStopped notification
5928 #1 => vCont s:p1.1;c
5930 #3 <= %Stopped T05 p1.1
5935 #8 (infrun handles the stop for p1.1 and continues stepping)
5936 #9 => vCont s:p1.1;c
5938 The last vCont above would resume thread p1.2 by mistake, because
5939 the server has no idea that the event for p1.2 had not been
5942 The server side must similarly ignore resume actions for the
5943 thread that has a pending %Stopped notification (and any other
5944 threads with events pending), until GDB acks the notification
5945 with vStopped. Otherwise, e.g., the following case is
5948 #1 => g (or any other packet)
5950 #3 <= %Stopped T05 p1.2
5951 #4 => vCont s:p1.1;c
5954 Above, the server must not resume thread p1.2. GDB can't know
5955 that p1.2 stopped until it acks the %Stopped notification, and
5956 since from GDB's perspective all threads should be running, it
5959 Finally, special care must also be given to handling fork/vfork
5960 events. A (v)fork event actually tells us that two processes
5961 stopped -- the parent and the child. Until we follow the fork,
5962 we must not resume the child. Therefore, if we have a pending
5963 fork follow, we must not send a global wildcard resume action
5964 (vCont;c). We can still send process-wide wildcards though. */
5966 /* Start by assuming a global wildcard (vCont;c) is possible. */
5967 may_global_wildcard_vcont
= 1;
5969 /* And assume every process is individually wildcard-able too. */
5970 ALL_NON_EXITED_INFERIORS (inf
)
5972 if (inf
->priv
== NULL
)
5973 inf
->priv
= XNEW (struct private_inferior
);
5974 inf
->priv
->may_wildcard_vcont
= 1;
5977 /* Check for any pending events (not reported or processed yet) and
5978 disable process and global wildcard resumes appropriately. */
5979 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
5981 ALL_NON_EXITED_THREADS (tp
)
5983 /* If a thread of a process is not meant to be resumed, then we
5984 can't wildcard that process. */
5987 tp
->inf
->priv
->may_wildcard_vcont
= 0;
5989 /* And if we can't wildcard a process, we can't wildcard
5990 everything either. */
5991 may_global_wildcard_vcont
= 0;
5995 /* If a thread is the parent of an unfollowed fork, then we
5996 can't do a global wildcard, as that would resume the fork
5998 if (is_pending_fork_parent_thread (tp
))
5999 may_global_wildcard_vcont
= 0;
6002 /* Now let's build the vCont packet(s). Actions must be appended
6003 from narrower to wider scopes (thread -> process -> global). If
6004 we end up with too many actions for a single packet vcont_builder
6005 flushes the current vCont packet to the remote side and starts a
6007 vcont_builder_restart (&vcont_builder
);
6009 /* Threads first. */
6010 ALL_NON_EXITED_THREADS (tp
)
6012 struct private_thread_info
*remote_thr
= tp
->priv
;
6014 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6017 gdb_assert (!thread_is_in_step_over_chain (tp
));
6019 if (!remote_thr
->last_resume_step
6020 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6021 && tp
->inf
->priv
->may_wildcard_vcont
)
6023 /* We'll send a wildcard resume instead. */
6024 remote_thr
->vcont_resumed
= 1;
6028 vcont_builder_push_action (&vcont_builder
, tp
->ptid
,
6029 remote_thr
->last_resume_step
,
6030 remote_thr
->last_resume_sig
);
6031 remote_thr
->vcont_resumed
= 1;
6034 /* Now check whether we can send any process-wide wildcard. This is
6035 to avoid sending a global wildcard in the case nothing is
6036 supposed to be resumed. */
6037 any_process_wildcard
= 0;
6039 ALL_NON_EXITED_INFERIORS (inf
)
6041 if (inf
->priv
->may_wildcard_vcont
)
6043 any_process_wildcard
= 1;
6048 if (any_process_wildcard
)
6050 /* If all processes are wildcard-able, then send a single "c"
6051 action, otherwise, send an "all (-1) threads of process"
6052 continue action for each running process, if any. */
6053 if (may_global_wildcard_vcont
)
6055 vcont_builder_push_action (&vcont_builder
, minus_one_ptid
,
6060 ALL_NON_EXITED_INFERIORS (inf
)
6062 if (inf
->priv
->may_wildcard_vcont
)
6064 vcont_builder_push_action (&vcont_builder
,
6065 pid_to_ptid (inf
->pid
),
6072 vcont_builder_flush (&vcont_builder
);
6077 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6078 thread, all threads of a remote process, or all threads of all
6082 remote_stop_ns (ptid_t ptid
)
6084 struct remote_state
*rs
= get_remote_state ();
6086 char *endp
= rs
->buf
+ get_remote_packet_size ();
6088 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6089 remote_vcont_probe (rs
);
6091 if (!rs
->supports_vCont
.t
)
6092 error (_("Remote server does not support stopping threads"));
6094 if (ptid_equal (ptid
, minus_one_ptid
)
6095 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
6096 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6101 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6103 if (ptid_is_pid (ptid
))
6104 /* All (-1) threads of process. */
6105 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
6108 /* Small optimization: if we already have a stop reply for
6109 this thread, no use in telling the stub we want this
6111 if (peek_stop_reply (ptid
))
6117 write_ptid (p
, endp
, nptid
);
6120 /* In non-stop, we get an immediate OK reply. The stop reply will
6121 come in asynchronously by notification. */
6123 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6124 if (strcmp (rs
->buf
, "OK") != 0)
6125 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
6128 /* All-stop version of target_interrupt. Sends a break or a ^C to
6129 interrupt the remote target. It is undefined which thread of which
6130 process reports the interrupt. */
6133 remote_interrupt_as (void)
6135 struct remote_state
*rs
= get_remote_state ();
6137 rs
->ctrlc_pending_p
= 1;
6139 /* If the inferior is stopped already, but the core didn't know
6140 about it yet, just ignore the request. The cached wait status
6141 will be collected in remote_wait. */
6142 if (rs
->cached_wait_status
)
6145 /* Send interrupt_sequence to remote target. */
6146 send_interrupt_sequence ();
6149 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6150 the remote target. It is undefined which thread of which process
6151 reports the interrupt. Throws an error if the packet is not
6152 supported by the server. */
6155 remote_interrupt_ns (void)
6157 struct remote_state
*rs
= get_remote_state ();
6159 char *endp
= rs
->buf
+ get_remote_packet_size ();
6161 xsnprintf (p
, endp
- p
, "vCtrlC");
6163 /* In non-stop, we get an immediate OK reply. The stop reply will
6164 come in asynchronously by notification. */
6166 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6168 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6172 case PACKET_UNKNOWN
:
6173 error (_("No support for interrupting the remote target."));
6175 error (_("Interrupting target failed: %s"), rs
->buf
);
6179 /* Implement the to_stop function for the remote targets. */
6182 remote_stop (struct target_ops
*self
, ptid_t ptid
)
6185 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6187 if (target_is_non_stop_p ())
6188 remote_stop_ns (ptid
);
6191 /* We don't currently have a way to transparently pause the
6192 remote target in all-stop mode. Interrupt it instead. */
6193 remote_interrupt_as ();
6197 /* Implement the to_interrupt function for the remote targets. */
6200 remote_interrupt (struct target_ops
*self
, ptid_t ptid
)
6202 struct remote_state
*rs
= get_remote_state ();
6205 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6207 if (target_is_non_stop_p ())
6208 remote_interrupt_ns ();
6210 remote_interrupt_as ();
6213 /* Implement the to_pass_ctrlc function for the remote targets. */
6216 remote_pass_ctrlc (struct target_ops
*self
)
6218 struct remote_state
*rs
= get_remote_state ();
6221 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6223 /* If we're starting up, we're not fully synced yet. Quit
6225 if (rs
->starting_up
)
6227 /* If ^C has already been sent once, offer to disconnect. */
6228 else if (rs
->ctrlc_pending_p
)
6231 target_interrupt (inferior_ptid
);
6234 /* Ask the user what to do when an interrupt is received. */
6237 interrupt_query (void)
6239 struct remote_state
*rs
= get_remote_state ();
6241 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6243 if (query (_("The target is not responding to interrupt requests.\n"
6244 "Stop debugging it? ")))
6246 remote_unpush_target ();
6247 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6252 if (query (_("Interrupted while waiting for the program.\n"
6253 "Give up waiting? ")))
6258 /* Enable/disable target terminal ownership. Most targets can use
6259 terminal groups to control terminal ownership. Remote targets are
6260 different in that explicit transfer of ownership to/from GDB/target
6264 remote_terminal_inferior (struct target_ops
*self
)
6266 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
6267 idempotent. The event-loop GDB talking to an asynchronous target
6268 with a synchronous command calls this function from both
6269 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
6270 transfer the terminal to the target when it shouldn't this guard
6272 if (!remote_async_terminal_ours_p
)
6274 remote_async_terminal_ours_p
= 0;
6275 /* NOTE: At this point we could also register our selves as the
6276 recipient of all input. Any characters typed could then be
6277 passed on down to the target. */
6281 remote_terminal_ours (struct target_ops
*self
)
6283 /* See FIXME in remote_terminal_inferior. */
6284 if (remote_async_terminal_ours_p
)
6286 remote_async_terminal_ours_p
= 1;
6290 remote_console_output (char *msg
)
6294 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6297 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6301 fputs_unfiltered (tb
, gdb_stdtarg
);
6303 gdb_flush (gdb_stdtarg
);
6306 typedef struct cached_reg
6309 gdb_byte data
[MAX_REGISTER_SIZE
];
6312 DEF_VEC_O(cached_reg_t
);
6314 typedef struct stop_reply
6316 struct notif_event base
;
6318 /* The identifier of the thread about this event */
6321 /* The remote state this event is associated with. When the remote
6322 connection, represented by a remote_state object, is closed,
6323 all the associated stop_reply events should be released. */
6324 struct remote_state
*rs
;
6326 struct target_waitstatus ws
;
6328 /* Expedited registers. This makes remote debugging a bit more
6329 efficient for those targets that provide critical registers as
6330 part of their normal status mechanism (as another roundtrip to
6331 fetch them is avoided). */
6332 VEC(cached_reg_t
) *regcache
;
6334 enum target_stop_reason stop_reason
;
6336 CORE_ADDR watch_data_address
;
6341 DECLARE_QUEUE_P (stop_reply_p
);
6342 DEFINE_QUEUE_P (stop_reply_p
);
6343 /* The list of already fetched and acknowledged stop events. This
6344 queue is used for notification Stop, and other notifications
6345 don't need queue for their events, because the notification events
6346 of Stop can't be consumed immediately, so that events should be
6347 queued first, and be consumed by remote_wait_{ns,as} one per
6348 time. Other notifications can consume their events immediately,
6349 so queue is not needed for them. */
6350 static QUEUE (stop_reply_p
) *stop_reply_queue
;
6353 stop_reply_xfree (struct stop_reply
*r
)
6355 notif_event_xfree ((struct notif_event
*) r
);
6358 /* Return the length of the stop reply queue. */
6361 stop_reply_queue_length (void)
6363 return QUEUE_length (stop_reply_p
, stop_reply_queue
);
6367 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
6368 struct notif_event
*event
)
6370 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6374 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
6375 struct notif_event
*event
)
6377 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6380 putpkt (self
->ack_command
);
6382 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6383 /* We got an unknown stop reply. */
6384 error (_("Unknown stop reply"));
6386 push_stop_reply (stop_reply
);
6390 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
6392 /* We can't get pending events in remote_notif_process for
6393 notification stop, and we have to do this in remote_wait_ns
6394 instead. If we fetch all queued events from stub, remote stub
6395 may exit and we have no chance to process them back in
6397 mark_async_event_handler (remote_async_inferior_event_token
);
6402 stop_reply_dtr (struct notif_event
*event
)
6404 struct stop_reply
*r
= (struct stop_reply
*) event
;
6406 VEC_free (cached_reg_t
, r
->regcache
);
6409 static struct notif_event
*
6410 remote_notif_stop_alloc_reply (void)
6412 /* We cast to a pointer to the "base class". */
6413 struct notif_event
*r
= (struct notif_event
*) XNEW (struct stop_reply
);
6415 r
->dtr
= stop_reply_dtr
;
6420 /* A client of notification Stop. */
6422 struct notif_client notif_client_stop
=
6426 remote_notif_stop_parse
,
6427 remote_notif_stop_ack
,
6428 remote_notif_stop_can_get_pending_events
,
6429 remote_notif_stop_alloc_reply
,
6433 /* A parameter to pass data in and out. */
6435 struct queue_iter_param
6438 struct stop_reply
*output
;
6441 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6442 the pid of the process that owns the threads we want to check, or
6443 -1 if we want to check all threads. */
6446 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6449 if (ws
->kind
== TARGET_WAITKIND_FORKED
6450 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6452 if (event_pid
== -1 || event_pid
== ptid_get_pid (thread_ptid
))
6459 /* Return the thread's pending status used to determine whether the
6460 thread is a fork parent stopped at a fork event. */
6462 static struct target_waitstatus
*
6463 thread_pending_fork_status (struct thread_info
*thread
)
6465 if (thread
->suspend
.waitstatus_pending_p
)
6466 return &thread
->suspend
.waitstatus
;
6468 return &thread
->pending_follow
;
6471 /* Determine if THREAD is a pending fork parent thread. */
6474 is_pending_fork_parent_thread (struct thread_info
*thread
)
6476 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6479 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6482 /* Check whether EVENT is a fork event, and if it is, remove the
6483 fork child from the context list passed in DATA. */
6486 remove_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
6487 QUEUE_ITER (stop_reply_p
) *iter
,
6491 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6492 struct threads_listing_context
*context
6493 = (struct threads_listing_context
*) param
->input
;
6495 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6496 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6497 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6498 threads_listing_context_remove (&event
->ws
, context
);
6503 /* If CONTEXT contains any fork child threads that have not been
6504 reported yet, remove them from the CONTEXT list. If such a
6505 thread exists it is because we are stopped at a fork catchpoint
6506 and have not yet called follow_fork, which will set up the
6507 host-side data structures for the new process. */
6510 remove_new_fork_children (struct threads_listing_context
*context
)
6512 struct thread_info
* thread
;
6514 struct notif_client
*notif
= ¬if_client_stop
;
6515 struct queue_iter_param param
;
6517 /* For any threads stopped at a fork event, remove the corresponding
6518 fork child threads from the CONTEXT list. */
6519 ALL_NON_EXITED_THREADS (thread
)
6521 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6523 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6525 threads_listing_context_remove (ws
, context
);
6529 /* Check for any pending fork events (not reported or processed yet)
6530 in process PID and remove those fork child threads from the
6531 CONTEXT list as well. */
6532 remote_notif_get_pending_events (notif
);
6533 param
.input
= context
;
6534 param
.output
= NULL
;
6535 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6536 remove_child_of_pending_fork
, ¶m
);
6539 /* Check whether EVENT would prevent a global or process wildcard
6543 check_pending_event_prevents_wildcard_vcont_callback
6544 (QUEUE (stop_reply_p
) *q
,
6545 QUEUE_ITER (stop_reply_p
) *iter
,
6549 struct inferior
*inf
;
6550 int *may_global_wildcard_vcont
= (int *) data
;
6552 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6553 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6556 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6557 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6558 *may_global_wildcard_vcont
= 0;
6560 inf
= find_inferior_ptid (event
->ptid
);
6562 /* This may be the first time we heard about this process.
6563 Regardless, we must not do a global wildcard resume, otherwise
6564 we'd resume this process too. */
6565 *may_global_wildcard_vcont
= 0;
6567 inf
->priv
->may_wildcard_vcont
= 0;
6572 /* Check whether any event pending in the vStopped queue would prevent
6573 a global or process wildcard vCont action. Clear
6574 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6575 and clear the event inferior's may_wildcard_vcont flag if we can't
6576 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6579 check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard
)
6581 struct notif_client
*notif
= ¬if_client_stop
;
6583 remote_notif_get_pending_events (notif
);
6584 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6585 check_pending_event_prevents_wildcard_vcont_callback
,
6586 may_global_wildcard
);
6589 /* Remove stop replies in the queue if its pid is equal to the given
6593 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
6594 QUEUE_ITER (stop_reply_p
) *iter
,
6598 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6599 struct inferior
*inf
= (struct inferior
*) param
->input
;
6601 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
6603 stop_reply_xfree (event
);
6604 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6610 /* Discard all pending stop replies of inferior INF. */
6613 discard_pending_stop_replies (struct inferior
*inf
)
6615 struct queue_iter_param param
;
6616 struct stop_reply
*reply
;
6617 struct remote_state
*rs
= get_remote_state ();
6618 struct remote_notif_state
*rns
= rs
->notif_state
;
6620 /* This function can be notified when an inferior exists. When the
6621 target is not remote, the notification state is NULL. */
6622 if (rs
->remote_desc
== NULL
)
6625 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
6627 /* Discard the in-flight notification. */
6628 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
6630 stop_reply_xfree (reply
);
6631 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
6635 param
.output
= NULL
;
6636 /* Discard the stop replies we have already pulled with
6638 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6639 remove_stop_reply_for_inferior
, ¶m
);
6642 /* If its remote state is equal to the given remote state,
6643 remove EVENT from the stop reply queue. */
6646 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
6647 QUEUE_ITER (stop_reply_p
) *iter
,
6651 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6652 struct remote_state
*rs
= (struct remote_state
*) param
->input
;
6654 if (event
->rs
== rs
)
6656 stop_reply_xfree (event
);
6657 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6663 /* Discard the stop replies for RS in stop_reply_queue. */
6666 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
6668 struct queue_iter_param param
;
6671 param
.output
= NULL
;
6672 /* Discard the stop replies we have already pulled with
6674 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6675 remove_stop_reply_of_remote_state
, ¶m
);
6678 /* A parameter to pass data in and out. */
6681 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
6682 QUEUE_ITER (stop_reply_p
) *iter
,
6686 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6687 ptid_t
*ptid
= (ptid_t
*) param
->input
;
6689 if (ptid_match (event
->ptid
, *ptid
))
6691 param
->output
= event
;
6692 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6699 /* Remove the first reply in 'stop_reply_queue' which matches
6702 static struct stop_reply
*
6703 remote_notif_remove_queued_reply (ptid_t ptid
)
6705 struct queue_iter_param param
;
6707 param
.input
= &ptid
;
6708 param
.output
= NULL
;
6710 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6711 remote_notif_remove_once_on_match
, ¶m
);
6713 fprintf_unfiltered (gdb_stdlog
,
6714 "notif: discard queued event: 'Stop' in %s\n",
6715 target_pid_to_str (ptid
));
6717 return param
.output
;
6720 /* Look for a queued stop reply belonging to PTID. If one is found,
6721 remove it from the queue, and return it. Returns NULL if none is
6722 found. If there are still queued events left to process, tell the
6723 event loop to get back to target_wait soon. */
6725 static struct stop_reply
*
6726 queued_stop_reply (ptid_t ptid
)
6728 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
6730 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6731 /* There's still at least an event left. */
6732 mark_async_event_handler (remote_async_inferior_event_token
);
6737 /* Push a fully parsed stop reply in the stop reply queue. Since we
6738 know that we now have at least one queued event left to pass to the
6739 core side, tell the event loop to get back to target_wait soon. */
6742 push_stop_reply (struct stop_reply
*new_event
)
6744 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
6747 fprintf_unfiltered (gdb_stdlog
,
6748 "notif: push 'Stop' %s to queue %d\n",
6749 target_pid_to_str (new_event
->ptid
),
6750 QUEUE_length (stop_reply_p
,
6753 mark_async_event_handler (remote_async_inferior_event_token
);
6757 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
6758 QUEUE_ITER (stop_reply_p
) *iter
,
6759 struct stop_reply
*event
,
6762 ptid_t
*ptid
= (ptid_t
*) data
;
6764 return !(ptid_equal (*ptid
, event
->ptid
)
6765 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
6768 /* Returns true if we have a stop reply for PTID. */
6771 peek_stop_reply (ptid_t ptid
)
6773 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6774 stop_reply_match_ptid_and_ws
, &ptid
);
6777 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
6778 starting with P and ending with PEND matches PREFIX. */
6781 strprefix (const char *p
, const char *pend
, const char *prefix
)
6783 for ( ; p
< pend
; p
++, prefix
++)
6786 return *prefix
== '\0';
6789 /* Parse the stop reply in BUF. Either the function succeeds, and the
6790 result is stored in EVENT, or throws an error. */
6793 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
6795 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6800 event
->ptid
= null_ptid
;
6801 event
->rs
= get_remote_state ();
6802 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
6803 event
->ws
.value
.integer
= 0;
6804 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6805 event
->regcache
= NULL
;
6810 case 'T': /* Status with PC, SP, FP, ... */
6811 /* Expedited reply, containing Signal, {regno, reg} repeat. */
6812 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
6814 n... = register number
6815 r... = register contents
6818 p
= &buf
[3]; /* after Txx */
6824 p1
= strchr (p
, ':');
6826 error (_("Malformed packet(a) (missing colon): %s\n\
6830 error (_("Malformed packet(a) (missing register number): %s\n\
6834 /* Some "registers" are actually extended stop information.
6835 Note if you're adding a new entry here: GDB 7.9 and
6836 earlier assume that all register "numbers" that start
6837 with an hex digit are real register numbers. Make sure
6838 the server only sends such a packet if it knows the
6839 client understands it. */
6841 if (strprefix (p
, p1
, "thread"))
6842 event
->ptid
= read_ptid (++p1
, &p
);
6843 else if (strprefix (p
, p1
, "syscall_entry"))
6847 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
6848 p
= unpack_varlen_hex (++p1
, &sysno
);
6849 event
->ws
.value
.syscall_number
= (int) sysno
;
6851 else if (strprefix (p
, p1
, "syscall_return"))
6855 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
6856 p
= unpack_varlen_hex (++p1
, &sysno
);
6857 event
->ws
.value
.syscall_number
= (int) sysno
;
6859 else if (strprefix (p
, p1
, "watch")
6860 || strprefix (p
, p1
, "rwatch")
6861 || strprefix (p
, p1
, "awatch"))
6863 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
6864 p
= unpack_varlen_hex (++p1
, &addr
);
6865 event
->watch_data_address
= (CORE_ADDR
) addr
;
6867 else if (strprefix (p
, p1
, "swbreak"))
6869 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
6871 /* Make sure the stub doesn't forget to indicate support
6873 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
6874 error (_("Unexpected swbreak stop reason"));
6876 /* The value part is documented as "must be empty",
6877 though we ignore it, in case we ever decide to make
6878 use of it in a backward compatible way. */
6879 p
= strchrnul (p1
+ 1, ';');
6881 else if (strprefix (p
, p1
, "hwbreak"))
6883 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
6885 /* Make sure the stub doesn't forget to indicate support
6887 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
6888 error (_("Unexpected hwbreak stop reason"));
6891 p
= strchrnul (p1
+ 1, ';');
6893 else if (strprefix (p
, p1
, "library"))
6895 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
6896 p
= strchrnul (p1
+ 1, ';');
6898 else if (strprefix (p
, p1
, "replaylog"))
6900 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
6901 /* p1 will indicate "begin" or "end", but it makes
6902 no difference for now, so ignore it. */
6903 p
= strchrnul (p1
+ 1, ';');
6905 else if (strprefix (p
, p1
, "core"))
6909 p
= unpack_varlen_hex (++p1
, &c
);
6912 else if (strprefix (p
, p1
, "fork"))
6914 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6915 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
6917 else if (strprefix (p
, p1
, "vfork"))
6919 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6920 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
6922 else if (strprefix (p
, p1
, "vforkdone"))
6924 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
6925 p
= strchrnul (p1
+ 1, ';');
6927 else if (strprefix (p
, p1
, "exec"))
6930 char pathname
[PATH_MAX
];
6933 /* Determine the length of the execd pathname. */
6934 p
= unpack_varlen_hex (++p1
, &ignored
);
6935 pathlen
= (p
- p1
) / 2;
6937 /* Save the pathname for event reporting and for
6938 the next run command. */
6939 hex2bin (p1
, (gdb_byte
*) pathname
, pathlen
);
6940 pathname
[pathlen
] = '\0';
6942 /* This is freed during event handling. */
6943 event
->ws
.value
.execd_pathname
= xstrdup (pathname
);
6944 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
6946 /* Skip the registers included in this packet, since
6947 they may be for an architecture different from the
6948 one used by the original program. */
6951 else if (strprefix (p
, p1
, "create"))
6953 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
6954 p
= strchrnul (p1
+ 1, ';');
6963 p
= strchrnul (p1
+ 1, ';');
6968 /* Maybe a real ``P'' register number. */
6969 p_temp
= unpack_varlen_hex (p
, &pnum
);
6970 /* If the first invalid character is the colon, we got a
6971 register number. Otherwise, it's an unknown stop
6975 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
6976 cached_reg_t cached_reg
;
6979 error (_("Remote sent bad register number %s: %s\n\
6981 hex_string (pnum
), p
, buf
);
6983 cached_reg
.num
= reg
->regnum
;
6986 fieldsize
= hex2bin (p
, cached_reg
.data
,
6987 register_size (target_gdbarch (),
6990 if (fieldsize
< register_size (target_gdbarch (),
6992 warning (_("Remote reply is too short: %s"), buf
);
6994 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
6998 /* Not a number. Silently skip unknown optional
7000 p
= strchrnul (p1
+ 1, ';');
7005 error (_("Remote register badly formatted: %s\nhere: %s"),
7010 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7014 case 'S': /* Old style status, just signal only. */
7018 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7019 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7020 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7021 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7023 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7026 case 'w': /* Thread exited. */
7031 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7032 p
= unpack_varlen_hex (&buf
[1], &value
);
7033 event
->ws
.value
.integer
= value
;
7035 error (_("stop reply packet badly formatted: %s"), buf
);
7036 event
->ptid
= read_ptid (++p
, NULL
);
7039 case 'W': /* Target exited. */
7046 /* GDB used to accept only 2 hex chars here. Stubs should
7047 only send more if they detect GDB supports multi-process
7049 p
= unpack_varlen_hex (&buf
[1], &value
);
7053 /* The remote process exited. */
7054 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7055 event
->ws
.value
.integer
= value
;
7059 /* The remote process exited with a signal. */
7060 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7061 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7062 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7064 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7067 /* If no process is specified, assume inferior_ptid. */
7068 pid
= ptid_get_pid (inferior_ptid
);
7077 else if (startswith (p
, "process:"))
7081 p
+= sizeof ("process:") - 1;
7082 unpack_varlen_hex (p
, &upid
);
7086 error (_("unknown stop reply packet: %s"), buf
);
7089 error (_("unknown stop reply packet: %s"), buf
);
7090 event
->ptid
= pid_to_ptid (pid
);
7094 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7095 event
->ptid
= minus_one_ptid
;
7099 if (target_is_non_stop_p () && ptid_equal (event
->ptid
, null_ptid
))
7100 error (_("No process or thread specified in stop reply: %s"), buf
);
7103 /* When the stub wants to tell GDB about a new notification reply, it
7104 sends a notification (%Stop, for example). Those can come it at
7105 any time, hence, we have to make sure that any pending
7106 putpkt/getpkt sequence we're making is finished, before querying
7107 the stub for more events with the corresponding ack command
7108 (vStopped, for example). E.g., if we started a vStopped sequence
7109 immediately upon receiving the notification, something like this
7117 1.6) <-- (registers reply to step #1.3)
7119 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7122 To solve this, whenever we parse a %Stop notification successfully,
7123 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7124 doing whatever we were doing:
7130 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7131 2.5) <-- (registers reply to step #2.3)
7133 Eventualy after step #2.5, we return to the event loop, which
7134 notices there's an event on the
7135 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7136 associated callback --- the function below. At this point, we're
7137 always safe to start a vStopped sequence. :
7140 2.7) <-- T05 thread:2
7146 remote_notif_get_pending_events (struct notif_client
*nc
)
7148 struct remote_state
*rs
= get_remote_state ();
7150 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7153 fprintf_unfiltered (gdb_stdlog
,
7154 "notif: process: '%s' ack pending event\n",
7158 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
7159 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7163 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7164 if (strcmp (rs
->buf
, "OK") == 0)
7167 remote_notif_ack (nc
, rs
->buf
);
7173 fprintf_unfiltered (gdb_stdlog
,
7174 "notif: process: '%s' no pending reply\n",
7179 /* Called when it is decided that STOP_REPLY holds the info of the
7180 event that is to be returned to the core. This function always
7181 destroys STOP_REPLY. */
7184 process_stop_reply (struct stop_reply
*stop_reply
,
7185 struct target_waitstatus
*status
)
7189 *status
= stop_reply
->ws
;
7190 ptid
= stop_reply
->ptid
;
7192 /* If no thread/process was reported by the stub, assume the current
7194 if (ptid_equal (ptid
, null_ptid
))
7195 ptid
= inferior_ptid
;
7197 if (status
->kind
!= TARGET_WAITKIND_EXITED
7198 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7199 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7201 struct private_thread_info
*remote_thr
;
7203 /* Expedited registers. */
7204 if (stop_reply
->regcache
)
7206 struct regcache
*regcache
7207 = get_thread_arch_regcache (ptid
, target_gdbarch ());
7212 VEC_iterate(cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
7214 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
7215 VEC_free (cached_reg_t
, stop_reply
->regcache
);
7218 remote_notice_new_inferior (ptid
, 0);
7219 remote_thr
= get_private_info_ptid (ptid
);
7220 remote_thr
->core
= stop_reply
->core
;
7221 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7222 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7223 remote_thr
->vcont_resumed
= 0;
7226 stop_reply_xfree (stop_reply
);
7230 /* The non-stop mode version of target_wait. */
7233 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7235 struct remote_state
*rs
= get_remote_state ();
7236 struct stop_reply
*stop_reply
;
7240 /* If in non-stop mode, get out of getpkt even if a
7241 notification is received. */
7243 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7244 0 /* forever */, &is_notif
);
7247 if (ret
!= -1 && !is_notif
)
7250 case 'E': /* Error of some sort. */
7251 /* We're out of sync with the target now. Did it continue
7252 or not? We can't tell which thread it was in non-stop,
7253 so just ignore this. */
7254 warning (_("Remote failure reply: %s"), rs
->buf
);
7256 case 'O': /* Console output. */
7257 remote_console_output (rs
->buf
+ 1);
7260 warning (_("Invalid remote reply: %s"), rs
->buf
);
7264 /* Acknowledge a pending stop reply that may have arrived in the
7266 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7267 remote_notif_get_pending_events (¬if_client_stop
);
7269 /* If indeed we noticed a stop reply, we're done. */
7270 stop_reply
= queued_stop_reply (ptid
);
7271 if (stop_reply
!= NULL
)
7272 return process_stop_reply (stop_reply
, status
);
7274 /* Still no event. If we're just polling for an event, then
7275 return to the event loop. */
7276 if (options
& TARGET_WNOHANG
)
7278 status
->kind
= TARGET_WAITKIND_IGNORE
;
7279 return minus_one_ptid
;
7282 /* Otherwise do a blocking wait. */
7283 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7284 1 /* forever */, &is_notif
);
7288 /* Wait until the remote machine stops, then return, storing status in
7289 STATUS just as `wait' would. */
7292 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7294 struct remote_state
*rs
= get_remote_state ();
7295 ptid_t event_ptid
= null_ptid
;
7297 struct stop_reply
*stop_reply
;
7301 status
->kind
= TARGET_WAITKIND_IGNORE
;
7302 status
->value
.integer
= 0;
7304 stop_reply
= queued_stop_reply (ptid
);
7305 if (stop_reply
!= NULL
)
7306 return process_stop_reply (stop_reply
, status
);
7308 if (rs
->cached_wait_status
)
7309 /* Use the cached wait status, but only once. */
7310 rs
->cached_wait_status
= 0;
7315 int forever
= ((options
& TARGET_WNOHANG
) == 0
7316 && wait_forever_enabled_p
);
7318 if (!rs
->waiting_for_stop_reply
)
7320 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7321 return minus_one_ptid
;
7324 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7325 _never_ wait for ever -> test on target_is_async_p().
7326 However, before we do that we need to ensure that the caller
7327 knows how to take the target into/out of async mode. */
7328 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7329 forever
, &is_notif
);
7331 /* GDB gets a notification. Return to core as this event is
7333 if (ret
!= -1 && is_notif
)
7334 return minus_one_ptid
;
7336 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7337 return minus_one_ptid
;
7342 /* Assume that the target has acknowledged Ctrl-C unless we receive
7343 an 'F' or 'O' packet. */
7344 if (buf
[0] != 'F' && buf
[0] != 'O')
7345 rs
->ctrlc_pending_p
= 0;
7349 case 'E': /* Error of some sort. */
7350 /* We're out of sync with the target now. Did it continue or
7351 not? Not is more likely, so report a stop. */
7352 rs
->waiting_for_stop_reply
= 0;
7354 warning (_("Remote failure reply: %s"), buf
);
7355 status
->kind
= TARGET_WAITKIND_STOPPED
;
7356 status
->value
.sig
= GDB_SIGNAL_0
;
7358 case 'F': /* File-I/O request. */
7359 /* GDB may access the inferior memory while handling the File-I/O
7360 request, but we don't want GDB accessing memory while waiting
7361 for a stop reply. See the comments in putpkt_binary. Set
7362 waiting_for_stop_reply to 0 temporarily. */
7363 rs
->waiting_for_stop_reply
= 0;
7364 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
7365 rs
->ctrlc_pending_p
= 0;
7366 /* GDB handled the File-I/O request, and the target is running
7367 again. Keep waiting for events. */
7368 rs
->waiting_for_stop_reply
= 1;
7370 case 'N': case 'T': case 'S': case 'X': case 'W':
7372 struct stop_reply
*stop_reply
;
7374 /* There is a stop reply to handle. */
7375 rs
->waiting_for_stop_reply
= 0;
7378 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
7381 event_ptid
= process_stop_reply (stop_reply
, status
);
7384 case 'O': /* Console output. */
7385 remote_console_output (buf
+ 1);
7388 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7390 /* Zero length reply means that we tried 'S' or 'C' and the
7391 remote system doesn't support it. */
7392 target_terminal_ours_for_output ();
7394 ("Can't send signals to this remote system. %s not sent.\n",
7395 gdb_signal_to_name (rs
->last_sent_signal
));
7396 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7397 target_terminal_inferior ();
7399 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7403 /* else fallthrough */
7405 warning (_("Invalid remote reply: %s"), buf
);
7409 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7410 return minus_one_ptid
;
7411 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7413 /* Nothing interesting happened. If we're doing a non-blocking
7414 poll, we're done. Otherwise, go back to waiting. */
7415 if (options
& TARGET_WNOHANG
)
7416 return minus_one_ptid
;
7420 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7421 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7423 if (!ptid_equal (event_ptid
, null_ptid
))
7424 record_currthread (rs
, event_ptid
);
7426 event_ptid
= inferior_ptid
;
7429 /* A process exit. Invalidate our notion of current thread. */
7430 record_currthread (rs
, minus_one_ptid
);
7435 /* Wait until the remote machine stops, then return, storing status in
7436 STATUS just as `wait' would. */
7439 remote_wait (struct target_ops
*ops
,
7440 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7444 if (target_is_non_stop_p ())
7445 event_ptid
= remote_wait_ns (ptid
, status
, options
);
7447 event_ptid
= remote_wait_as (ptid
, status
, options
);
7449 if (target_is_async_p ())
7451 /* If there are are events left in the queue tell the event loop
7453 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
7454 mark_async_event_handler (remote_async_inferior_event_token
);
7460 /* Fetch a single register using a 'p' packet. */
7463 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
7465 struct remote_state
*rs
= get_remote_state ();
7467 char regp
[MAX_REGISTER_SIZE
];
7470 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7473 if (reg
->pnum
== -1)
7478 p
+= hexnumstr (p
, reg
->pnum
);
7481 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7485 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
7489 case PACKET_UNKNOWN
:
7492 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7493 gdbarch_register_name (get_regcache_arch (regcache
),
7498 /* If this register is unfetchable, tell the regcache. */
7501 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7505 /* Otherwise, parse and supply the value. */
7511 error (_("fetch_register_using_p: early buf termination"));
7513 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7516 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
7520 /* Fetch the registers included in the target's 'g' packet. */
7523 send_g_packet (void)
7525 struct remote_state
*rs
= get_remote_state ();
7528 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
7529 remote_send (&rs
->buf
, &rs
->buf_size
);
7531 /* We can get out of synch in various cases. If the first character
7532 in the buffer is not a hex character, assume that has happened
7533 and try to fetch another packet to read. */
7534 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7535 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7536 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7537 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7540 fprintf_unfiltered (gdb_stdlog
,
7541 "Bad register packet; fetching a new packet\n");
7542 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7545 buf_len
= strlen (rs
->buf
);
7547 /* Sanity check the received packet. */
7548 if (buf_len
% 2 != 0)
7549 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
7555 process_g_packet (struct regcache
*regcache
)
7557 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7558 struct remote_state
*rs
= get_remote_state ();
7559 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7564 buf_len
= strlen (rs
->buf
);
7566 /* Further sanity checks, with knowledge of the architecture. */
7567 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7568 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
7570 /* Save the size of the packet sent to us by the target. It is used
7571 as a heuristic when determining the max size of packets that the
7572 target can safely receive. */
7573 if (rsa
->actual_register_packet_size
== 0)
7574 rsa
->actual_register_packet_size
= buf_len
;
7576 /* If this is smaller than we guessed the 'g' packet would be,
7577 update our records. A 'g' reply that doesn't include a register's
7578 value implies either that the register is not available, or that
7579 the 'p' packet must be used. */
7580 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7582 long sizeof_g_packet
= buf_len
/ 2;
7584 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7586 long offset
= rsa
->regs
[i
].offset
;
7587 long reg_size
= register_size (gdbarch
, i
);
7589 if (rsa
->regs
[i
].pnum
== -1)
7592 if (offset
>= sizeof_g_packet
)
7593 rsa
->regs
[i
].in_g_packet
= 0;
7594 else if (offset
+ reg_size
> sizeof_g_packet
)
7595 error (_("Truncated register %d in remote 'g' packet"), i
);
7597 rsa
->regs
[i
].in_g_packet
= 1;
7600 /* Looks valid enough, we can assume this is the correct length
7601 for a 'g' packet. It's important not to adjust
7602 rsa->sizeof_g_packet if we have truncated registers otherwise
7603 this "if" won't be run the next time the method is called
7604 with a packet of the same size and one of the internal errors
7605 below will trigger instead. */
7606 rsa
->sizeof_g_packet
= sizeof_g_packet
;
7609 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
7611 /* Unimplemented registers read as all bits zero. */
7612 memset (regs
, 0, rsa
->sizeof_g_packet
);
7614 /* Reply describes registers byte by byte, each byte encoded as two
7615 hex characters. Suck them all up, then supply them to the
7616 register cacheing/storage mechanism. */
7619 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
7621 if (p
[0] == 0 || p
[1] == 0)
7622 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
7623 internal_error (__FILE__
, __LINE__
,
7624 _("unexpected end of 'g' packet reply"));
7626 if (p
[0] == 'x' && p
[1] == 'x')
7627 regs
[i
] = 0; /* 'x' */
7629 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7633 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7635 struct packet_reg
*r
= &rsa
->regs
[i
];
7636 long reg_size
= register_size (gdbarch
, i
);
7640 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
))
7641 /* This shouldn't happen - we adjusted in_g_packet above. */
7642 internal_error (__FILE__
, __LINE__
,
7643 _("unexpected end of 'g' packet reply"));
7644 else if (rs
->buf
[r
->offset
* 2] == 'x')
7646 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
7647 /* The register isn't available, mark it as such (at
7648 the same time setting the value to zero). */
7649 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
7652 regcache_raw_supply (regcache
, r
->regnum
,
7659 fetch_registers_using_g (struct regcache
*regcache
)
7662 process_g_packet (regcache
);
7665 /* Make the remote selected traceframe match GDB's selected
7669 set_remote_traceframe (void)
7672 struct remote_state
*rs
= get_remote_state ();
7674 if (rs
->remote_traceframe_number
== get_traceframe_number ())
7677 /* Avoid recursion, remote_trace_find calls us again. */
7678 rs
->remote_traceframe_number
= get_traceframe_number ();
7680 newnum
= target_trace_find (tfind_number
,
7681 get_traceframe_number (), 0, 0, NULL
);
7683 /* Should not happen. If it does, all bets are off. */
7684 if (newnum
!= get_traceframe_number ())
7685 warning (_("could not set remote traceframe"));
7689 remote_fetch_registers (struct target_ops
*ops
,
7690 struct regcache
*regcache
, int regnum
)
7692 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7695 set_remote_traceframe ();
7696 set_general_thread (inferior_ptid
);
7700 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7702 gdb_assert (reg
!= NULL
);
7704 /* If this register might be in the 'g' packet, try that first -
7705 we are likely to read more than one register. If this is the
7706 first 'g' packet, we might be overly optimistic about its
7707 contents, so fall back to 'p'. */
7708 if (reg
->in_g_packet
)
7710 fetch_registers_using_g (regcache
);
7711 if (reg
->in_g_packet
)
7715 if (fetch_register_using_p (regcache
, reg
))
7718 /* This register is not available. */
7719 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7724 fetch_registers_using_g (regcache
);
7726 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7727 if (!rsa
->regs
[i
].in_g_packet
)
7728 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
7730 /* This register is not available. */
7731 regcache_raw_supply (regcache
, i
, NULL
);
7735 /* Prepare to store registers. Since we may send them all (using a
7736 'G' request), we have to read out the ones we don't want to change
7740 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
7742 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7744 gdb_byte buf
[MAX_REGISTER_SIZE
];
7746 /* Make sure the entire registers array is valid. */
7747 switch (packet_support (PACKET_P
))
7749 case PACKET_DISABLE
:
7750 case PACKET_SUPPORT_UNKNOWN
:
7751 /* Make sure all the necessary registers are cached. */
7752 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7753 if (rsa
->regs
[i
].in_g_packet
)
7754 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
7761 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
7762 packet was not recognized. */
7765 store_register_using_P (const struct regcache
*regcache
,
7766 struct packet_reg
*reg
)
7768 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7769 struct remote_state
*rs
= get_remote_state ();
7770 /* Try storing a single register. */
7771 char *buf
= rs
->buf
;
7772 gdb_byte regp
[MAX_REGISTER_SIZE
];
7775 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
7778 if (reg
->pnum
== -1)
7781 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
7782 p
= buf
+ strlen (buf
);
7783 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
7784 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
7786 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7788 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
7793 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
7794 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
7795 case PACKET_UNKNOWN
:
7798 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
7802 /* Store register REGNUM, or all registers if REGNUM == -1, from the
7803 contents of the register cache buffer. FIXME: ignores errors. */
7806 store_registers_using_G (const struct regcache
*regcache
)
7808 struct remote_state
*rs
= get_remote_state ();
7809 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7813 /* Extract all the registers in the regcache copying them into a
7818 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
7819 memset (regs
, 0, rsa
->sizeof_g_packet
);
7820 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7822 struct packet_reg
*r
= &rsa
->regs
[i
];
7825 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
7829 /* Command describes registers byte by byte,
7830 each byte encoded as two hex characters. */
7833 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
7835 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
7837 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7838 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7839 error (_("Could not write registers; remote failure reply '%s'"),
7843 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7844 of the register cache buffer. FIXME: ignores errors. */
7847 remote_store_registers (struct target_ops
*ops
,
7848 struct regcache
*regcache
, int regnum
)
7850 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7853 set_remote_traceframe ();
7854 set_general_thread (inferior_ptid
);
7858 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7860 gdb_assert (reg
!= NULL
);
7862 /* Always prefer to store registers using the 'P' packet if
7863 possible; we often change only a small number of registers.
7864 Sometimes we change a larger number; we'd need help from a
7865 higher layer to know to use 'G'. */
7866 if (store_register_using_P (regcache
, reg
))
7869 /* For now, don't complain if we have no way to write the
7870 register. GDB loses track of unavailable registers too
7871 easily. Some day, this may be an error. We don't have
7872 any way to read the register, either... */
7873 if (!reg
->in_g_packet
)
7876 store_registers_using_G (regcache
);
7880 store_registers_using_G (regcache
);
7882 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7883 if (!rsa
->regs
[i
].in_g_packet
)
7884 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
7885 /* See above for why we do not issue an error here. */
7890 /* Return the number of hex digits in num. */
7893 hexnumlen (ULONGEST num
)
7897 for (i
= 0; num
!= 0; i
++)
7900 return std::max (i
, 1);
7903 /* Set BUF to the minimum number of hex digits representing NUM. */
7906 hexnumstr (char *buf
, ULONGEST num
)
7908 int len
= hexnumlen (num
);
7910 return hexnumnstr (buf
, num
, len
);
7914 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7917 hexnumnstr (char *buf
, ULONGEST num
, int width
)
7923 for (i
= width
- 1; i
>= 0; i
--)
7925 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
7932 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7935 remote_address_masked (CORE_ADDR addr
)
7937 unsigned int address_size
= remote_address_size
;
7939 /* If "remoteaddresssize" was not set, default to target address size. */
7941 address_size
= gdbarch_addr_bit (target_gdbarch ());
7943 if (address_size
> 0
7944 && address_size
< (sizeof (ULONGEST
) * 8))
7946 /* Only create a mask when that mask can safely be constructed
7947 in a ULONGEST variable. */
7950 mask
= (mask
<< address_size
) - 1;
7956 /* Determine whether the remote target supports binary downloading.
7957 This is accomplished by sending a no-op memory write of zero length
7958 to the target at the specified address. It does not suffice to send
7959 the whole packet, since many stubs strip the eighth bit and
7960 subsequently compute a wrong checksum, which causes real havoc with
7963 NOTE: This can still lose if the serial line is not eight-bit
7964 clean. In cases like this, the user should clear "remote
7968 check_binary_download (CORE_ADDR addr
)
7970 struct remote_state
*rs
= get_remote_state ();
7972 switch (packet_support (PACKET_X
))
7974 case PACKET_DISABLE
:
7978 case PACKET_SUPPORT_UNKNOWN
:
7984 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7986 p
+= hexnumstr (p
, (ULONGEST
) 0);
7990 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
7991 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7993 if (rs
->buf
[0] == '\0')
7996 fprintf_unfiltered (gdb_stdlog
,
7997 "binary downloading NOT "
7998 "supported by target\n");
7999 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8004 fprintf_unfiltered (gdb_stdlog
,
8005 "binary downloading supported by target\n");
8006 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8013 /* Helper function to resize the payload in order to try to get a good
8014 alignment. We try to write an amount of data such that the next write will
8015 start on an address aligned on REMOTE_ALIGN_WRITES. */
8018 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8020 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8023 /* Write memory data directly to the remote machine.
8024 This does not inform the data cache; the data cache uses this.
8025 HEADER is the starting part of the packet.
8026 MEMADDR is the address in the remote memory space.
8027 MYADDR is the address of the buffer in our space.
8028 LEN_UNITS is the number of addressable units to write.
8029 UNIT_SIZE is the length in bytes of an addressable unit.
8030 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8031 should send data as binary ('X'), or hex-encoded ('M').
8033 The function creates packet of the form
8034 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8036 where encoding of <DATA> is terminated by PACKET_FORMAT.
8038 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8041 Return the transferred status, error or OK (an
8042 'enum target_xfer_status' value). Save the number of addressable units
8043 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8045 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8046 exchange between gdb and the stub could look like (?? in place of the
8052 -> $M1000,3:eeeeffffeeee#??
8056 <- eeeeffffeeeedddd */
8058 static enum target_xfer_status
8059 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8060 const gdb_byte
*myaddr
, ULONGEST len_units
,
8061 int unit_size
, ULONGEST
*xfered_len_units
,
8062 char packet_format
, int use_length
)
8064 struct remote_state
*rs
= get_remote_state ();
8070 int payload_capacity_bytes
;
8071 int payload_length_bytes
;
8073 if (packet_format
!= 'X' && packet_format
!= 'M')
8074 internal_error (__FILE__
, __LINE__
,
8075 _("remote_write_bytes_aux: bad packet format"));
8078 return TARGET_XFER_EOF
;
8080 payload_capacity_bytes
= get_memory_write_packet_size ();
8082 /* The packet buffer will be large enough for the payload;
8083 get_memory_packet_size ensures this. */
8086 /* Compute the size of the actual payload by subtracting out the
8087 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8089 payload_capacity_bytes
-= strlen ("$,:#NN");
8091 /* The comma won't be used. */
8092 payload_capacity_bytes
+= 1;
8093 payload_capacity_bytes
-= strlen (header
);
8094 payload_capacity_bytes
-= hexnumlen (memaddr
);
8096 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8098 strcat (rs
->buf
, header
);
8099 p
= rs
->buf
+ strlen (header
);
8101 /* Compute a best guess of the number of bytes actually transfered. */
8102 if (packet_format
== 'X')
8104 /* Best guess at number of bytes that will fit. */
8105 todo_units
= std::min (len_units
,
8106 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8108 payload_capacity_bytes
-= hexnumlen (todo_units
);
8109 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8113 /* Number of bytes that will fit. */
8115 = std::min (len_units
,
8116 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8118 payload_capacity_bytes
-= hexnumlen (todo_units
);
8119 todo_units
= std::min (todo_units
,
8120 (payload_capacity_bytes
/ unit_size
) / 2);
8123 if (todo_units
<= 0)
8124 internal_error (__FILE__
, __LINE__
,
8125 _("minimum packet size too small to write data"));
8127 /* If we already need another packet, then try to align the end
8128 of this packet to a useful boundary. */
8129 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8130 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8132 /* Append "<memaddr>". */
8133 memaddr
= remote_address_masked (memaddr
);
8134 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8141 /* Append the length and retain its location and size. It may need to be
8142 adjusted once the packet body has been created. */
8144 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8152 /* Append the packet body. */
8153 if (packet_format
== 'X')
8155 /* Binary mode. Send target system values byte by byte, in
8156 increasing byte addresses. Only escape certain critical
8158 payload_length_bytes
=
8159 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8160 &units_written
, payload_capacity_bytes
);
8162 /* If not all TODO units fit, then we'll need another packet. Make
8163 a second try to keep the end of the packet aligned. Don't do
8164 this if the packet is tiny. */
8165 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8169 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8171 if (new_todo_units
!= units_written
)
8172 payload_length_bytes
=
8173 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8174 (gdb_byte
*) p
, &units_written
,
8175 payload_capacity_bytes
);
8178 p
+= payload_length_bytes
;
8179 if (use_length
&& units_written
< todo_units
)
8181 /* Escape chars have filled up the buffer prematurely,
8182 and we have actually sent fewer units than planned.
8183 Fix-up the length field of the packet. Use the same
8184 number of characters as before. */
8185 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8187 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8192 /* Normal mode: Send target system values byte by byte, in
8193 increasing byte addresses. Each byte is encoded as a two hex
8195 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8196 units_written
= todo_units
;
8199 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8200 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8202 if (rs
->buf
[0] == 'E')
8203 return TARGET_XFER_E_IO
;
8205 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8206 send fewer units than we'd planned. */
8207 *xfered_len_units
= (ULONGEST
) units_written
;
8208 return TARGET_XFER_OK
;
8211 /* Write memory data directly to the remote machine.
8212 This does not inform the data cache; the data cache uses this.
8213 MEMADDR is the address in the remote memory space.
8214 MYADDR is the address of the buffer in our space.
8215 LEN is the number of bytes.
8217 Return the transferred status, error or OK (an
8218 'enum target_xfer_status' value). Save the number of bytes
8219 transferred in *XFERED_LEN. Only transfer a single packet. */
8221 static enum target_xfer_status
8222 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
8223 int unit_size
, ULONGEST
*xfered_len
)
8225 char *packet_format
= 0;
8227 /* Check whether the target supports binary download. */
8228 check_binary_download (memaddr
);
8230 switch (packet_support (PACKET_X
))
8233 packet_format
= "X";
8235 case PACKET_DISABLE
:
8236 packet_format
= "M";
8238 case PACKET_SUPPORT_UNKNOWN
:
8239 internal_error (__FILE__
, __LINE__
,
8240 _("remote_write_bytes: bad internal state"));
8242 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8245 return remote_write_bytes_aux (packet_format
,
8246 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8247 packet_format
[0], 1);
8250 /* Read memory data directly from the remote machine.
8251 This does not use the data cache; the data cache uses this.
8252 MEMADDR is the address in the remote memory space.
8253 MYADDR is the address of the buffer in our space.
8254 LEN_UNITS is the number of addressable memory units to read..
8255 UNIT_SIZE is the length in bytes of an addressable unit.
8257 Return the transferred status, error or OK (an
8258 'enum target_xfer_status' value). Save the number of bytes
8259 transferred in *XFERED_LEN_UNITS.
8261 See the comment of remote_write_bytes_aux for an example of
8262 memory read/write exchange between gdb and the stub. */
8264 static enum target_xfer_status
8265 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
8266 int unit_size
, ULONGEST
*xfered_len_units
)
8268 struct remote_state
*rs
= get_remote_state ();
8269 int buf_size_bytes
; /* Max size of packet output buffer. */
8274 buf_size_bytes
= get_memory_read_packet_size ();
8275 /* The packet buffer will be large enough for the payload;
8276 get_memory_packet_size ensures this. */
8278 /* Number of units that will fit. */
8279 todo_units
= std::min (len_units
,
8280 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8282 /* Construct "m"<memaddr>","<len>". */
8283 memaddr
= remote_address_masked (memaddr
);
8286 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8288 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8291 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8292 if (rs
->buf
[0] == 'E'
8293 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8294 && rs
->buf
[3] == '\0')
8295 return TARGET_XFER_E_IO
;
8296 /* Reply describes memory byte by byte, each byte encoded as two hex
8299 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8300 /* Return what we have. Let higher layers handle partial reads. */
8301 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8302 return TARGET_XFER_OK
;
8305 /* Using the set of read-only target sections of remote, read live
8308 For interface/parameters/return description see target.h,
8311 static enum target_xfer_status
8312 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
8313 ULONGEST memaddr
, ULONGEST len
,
8314 int unit_size
, ULONGEST
*xfered_len
)
8316 struct target_section
*secp
;
8317 struct target_section_table
*table
;
8319 secp
= target_section_by_addr (ops
, memaddr
);
8321 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8322 secp
->the_bfd_section
)
8325 struct target_section
*p
;
8326 ULONGEST memend
= memaddr
+ len
;
8328 table
= target_get_section_table (ops
);
8330 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8332 if (memaddr
>= p
->addr
)
8334 if (memend
<= p
->endaddr
)
8336 /* Entire transfer is within this section. */
8337 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8340 else if (memaddr
>= p
->endaddr
)
8342 /* This section ends before the transfer starts. */
8347 /* This section overlaps the transfer. Just do half. */
8348 len
= p
->endaddr
- memaddr
;
8349 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8356 return TARGET_XFER_EOF
;
8359 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8360 first if the requested memory is unavailable in traceframe.
8361 Otherwise, fall back to remote_read_bytes_1. */
8363 static enum target_xfer_status
8364 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
8365 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8366 ULONGEST
*xfered_len
)
8369 return TARGET_XFER_EOF
;
8371 if (get_traceframe_number () != -1)
8373 VEC(mem_range_s
) *available
;
8375 /* If we fail to get the set of available memory, then the
8376 target does not support querying traceframe info, and so we
8377 attempt reading from the traceframe anyway (assuming the
8378 target implements the old QTro packet then). */
8379 if (traceframe_available_memory (&available
, memaddr
, len
))
8381 struct cleanup
*old_chain
;
8383 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
8385 if (VEC_empty (mem_range_s
, available
)
8386 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
8388 enum target_xfer_status res
;
8390 /* Don't read into the traceframe's available
8392 if (!VEC_empty (mem_range_s
, available
))
8394 LONGEST oldlen
= len
;
8396 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
8397 gdb_assert (len
<= oldlen
);
8400 do_cleanups (old_chain
);
8402 /* This goes through the topmost target again. */
8403 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
8404 len
, unit_size
, xfered_len
);
8405 if (res
== TARGET_XFER_OK
)
8406 return TARGET_XFER_OK
;
8409 /* No use trying further, we know some memory starting
8410 at MEMADDR isn't available. */
8412 return TARGET_XFER_UNAVAILABLE
;
8416 /* Don't try to read more than how much is available, in
8417 case the target implements the deprecated QTro packet to
8418 cater for older GDBs (the target's knowledge of read-only
8419 sections may be outdated by now). */
8420 len
= VEC_index (mem_range_s
, available
, 0)->length
;
8422 do_cleanups (old_chain
);
8426 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8431 /* Sends a packet with content determined by the printf format string
8432 FORMAT and the remaining arguments, then gets the reply. Returns
8433 whether the packet was a success, a failure, or unknown. */
8435 static enum packet_result
remote_send_printf (const char *format
, ...)
8436 ATTRIBUTE_PRINTF (1, 2);
8438 static enum packet_result
8439 remote_send_printf (const char *format
, ...)
8441 struct remote_state
*rs
= get_remote_state ();
8442 int max_size
= get_remote_packet_size ();
8445 va_start (ap
, format
);
8448 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
8449 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8451 if (putpkt (rs
->buf
) < 0)
8452 error (_("Communication problem with target."));
8455 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8457 return packet_check_result (rs
->buf
);
8461 restore_remote_timeout (void *p
)
8463 int value
= *(int *)p
;
8465 remote_timeout
= value
;
8468 /* Flash writing can take quite some time. We'll set
8469 effectively infinite timeout for flash operations.
8470 In future, we'll need to decide on a better approach. */
8471 static const int remote_flash_timeout
= 1000;
8474 remote_flash_erase (struct target_ops
*ops
,
8475 ULONGEST address
, LONGEST length
)
8477 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8478 int saved_remote_timeout
= remote_timeout
;
8479 enum packet_result ret
;
8480 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8481 &saved_remote_timeout
);
8483 remote_timeout
= remote_flash_timeout
;
8485 ret
= remote_send_printf ("vFlashErase:%s,%s",
8486 phex (address
, addr_size
),
8490 case PACKET_UNKNOWN
:
8491 error (_("Remote target does not support flash erase"));
8493 error (_("Error erasing flash with vFlashErase packet"));
8498 do_cleanups (back_to
);
8501 static enum target_xfer_status
8502 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
8503 ULONGEST length
, ULONGEST
*xfered_len
,
8504 const gdb_byte
*data
)
8506 int saved_remote_timeout
= remote_timeout
;
8507 enum target_xfer_status ret
;
8508 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8509 &saved_remote_timeout
);
8511 remote_timeout
= remote_flash_timeout
;
8512 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8514 do_cleanups (back_to
);
8520 remote_flash_done (struct target_ops
*ops
)
8522 int saved_remote_timeout
= remote_timeout
;
8524 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
8525 &saved_remote_timeout
);
8527 remote_timeout
= remote_flash_timeout
;
8528 ret
= remote_send_printf ("vFlashDone");
8529 do_cleanups (back_to
);
8533 case PACKET_UNKNOWN
:
8534 error (_("Remote target does not support vFlashDone"));
8536 error (_("Error finishing flash operation"));
8543 remote_files_info (struct target_ops
*ignore
)
8545 puts_filtered ("Debugging a target over a serial line.\n");
8548 /* Stuff for dealing with the packets which are part of this protocol.
8549 See comment at top of file for details. */
8551 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8552 error to higher layers. Called when a serial error is detected.
8553 The exception message is STRING, followed by a colon and a blank,
8554 the system error message for errno at function entry and final dot
8555 for output compatibility with throw_perror_with_name. */
8558 unpush_and_perror (const char *string
)
8560 int saved_errno
= errno
;
8562 remote_unpush_target ();
8563 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8564 safe_strerror (saved_errno
));
8567 /* Read a single character from the remote end. The current quit
8568 handler is overridden to avoid quitting in the middle of packet
8569 sequence, as that would break communication with the remote server.
8570 See remote_serial_quit_handler for more detail. */
8573 readchar (int timeout
)
8576 struct remote_state
*rs
= get_remote_state ();
8577 struct cleanup
*old_chain
;
8579 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8581 rs
->got_ctrlc_during_io
= 0;
8583 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8585 if (rs
->got_ctrlc_during_io
)
8588 do_cleanups (old_chain
);
8593 switch ((enum serial_rc
) ch
)
8596 remote_unpush_target ();
8597 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8600 unpush_and_perror (_("Remote communication error. "
8601 "Target disconnected."));
8603 case SERIAL_TIMEOUT
:
8609 /* Wrapper for serial_write that closes the target and throws if
8610 writing fails. The current quit handler is overridden to avoid
8611 quitting in the middle of packet sequence, as that would break
8612 communication with the remote server. See
8613 remote_serial_quit_handler for more detail. */
8616 remote_serial_write (const char *str
, int len
)
8618 struct remote_state
*rs
= get_remote_state ();
8619 struct cleanup
*old_chain
;
8621 old_chain
= make_cleanup_override_quit_handler (remote_serial_quit_handler
);
8623 rs
->got_ctrlc_during_io
= 0;
8625 if (serial_write (rs
->remote_desc
, str
, len
))
8627 unpush_and_perror (_("Remote communication error. "
8628 "Target disconnected."));
8631 if (rs
->got_ctrlc_during_io
)
8634 do_cleanups (old_chain
);
8637 /* Send the command in *BUF to the remote machine, and read the reply
8638 into *BUF. Report an error if we get an error reply. Resize
8639 *BUF using xrealloc if necessary to hold the result, and update
8643 remote_send (char **buf
,
8647 getpkt (buf
, sizeof_buf
, 0);
8649 if ((*buf
)[0] == 'E')
8650 error (_("Remote failure reply: %s"), *buf
);
8653 /* Return a string representing an escaped version of BUF, of len N.
8654 E.g. \n is converted to \\n, \t to \\t, etc. */
8657 escape_buffer (const char *buf
, int n
)
8659 struct cleanup
*old_chain
;
8660 struct ui_file
*stb
;
8662 stb
= mem_fileopen ();
8663 old_chain
= make_cleanup_ui_file_delete (stb
);
8665 fputstrn_unfiltered (buf
, n
, '\\', stb
);
8666 std::string str
= ui_file_as_string (stb
);
8667 do_cleanups (old_chain
);
8671 /* Display a null-terminated packet on stdout, for debugging, using C
8675 print_packet (const char *buf
)
8677 puts_filtered ("\"");
8678 fputstr_filtered (buf
, '"', gdb_stdout
);
8679 puts_filtered ("\"");
8683 putpkt (const char *buf
)
8685 return putpkt_binary (buf
, strlen (buf
));
8688 /* Send a packet to the remote machine, with error checking. The data
8689 of the packet is in BUF. The string in BUF can be at most
8690 get_remote_packet_size () - 5 to account for the $, # and checksum,
8691 and for a possible /0 if we are debugging (remote_debug) and want
8692 to print the sent packet as a string. */
8695 putpkt_binary (const char *buf
, int cnt
)
8697 struct remote_state
*rs
= get_remote_state ();
8699 unsigned char csum
= 0;
8700 char *buf2
= (char *) xmalloc (cnt
+ 6);
8701 struct cleanup
*old_chain
= make_cleanup (xfree
, buf2
);
8707 /* Catch cases like trying to read memory or listing threads while
8708 we're waiting for a stop reply. The remote server wouldn't be
8709 ready to handle this request, so we'd hang and timeout. We don't
8710 have to worry about this in synchronous mode, because in that
8711 case it's not possible to issue a command while the target is
8712 running. This is not a problem in non-stop mode, because in that
8713 case, the stub is always ready to process serial input. */
8714 if (!target_is_non_stop_p ()
8715 && target_is_async_p ()
8716 && rs
->waiting_for_stop_reply
)
8718 error (_("Cannot execute this command while the target is running.\n"
8719 "Use the \"interrupt\" command to stop the target\n"
8720 "and then try again."));
8723 /* We're sending out a new packet. Make sure we don't look at a
8724 stale cached response. */
8725 rs
->cached_wait_status
= 0;
8727 /* Copy the packet into buffer BUF2, encapsulating it
8728 and giving it a checksum. */
8733 for (i
= 0; i
< cnt
; i
++)
8739 *p
++ = tohex ((csum
>> 4) & 0xf);
8740 *p
++ = tohex (csum
& 0xf);
8742 /* Send it over and over until we get a positive ack. */
8746 int started_error_output
= 0;
8752 std::string str
= escape_buffer (buf2
, p
- buf2
);
8754 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s...", str
.c_str ());
8755 gdb_flush (gdb_stdlog
);
8757 remote_serial_write (buf2
, p
- buf2
);
8759 /* If this is a no acks version of the remote protocol, send the
8760 packet and move on. */
8764 /* Read until either a timeout occurs (-2) or '+' is read.
8765 Handle any notification that arrives in the mean time. */
8768 ch
= readchar (remote_timeout
);
8776 case SERIAL_TIMEOUT
:
8779 if (started_error_output
)
8781 putchar_unfiltered ('\n');
8782 started_error_output
= 0;
8791 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
8792 do_cleanups (old_chain
);
8796 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
8798 case SERIAL_TIMEOUT
:
8802 do_cleanups (old_chain
);
8805 break; /* Retransmit buffer. */
8809 fprintf_unfiltered (gdb_stdlog
,
8810 "Packet instead of Ack, ignoring it\n");
8811 /* It's probably an old response sent because an ACK
8812 was lost. Gobble up the packet and ack it so it
8813 doesn't get retransmitted when we resend this
8816 remote_serial_write ("+", 1);
8817 continue; /* Now, go look for +. */
8824 /* If we got a notification, handle it, and go back to looking
8826 /* We've found the start of a notification. Now
8827 collect the data. */
8828 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
8833 std::string str
= escape_buffer (rs
->buf
, val
);
8835 fprintf_unfiltered (gdb_stdlog
,
8836 " Notification received: %s\n",
8839 handle_notification (rs
->notif_state
, rs
->buf
);
8840 /* We're in sync now, rewait for the ack. */
8847 if (!started_error_output
)
8849 started_error_output
= 1;
8850 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8852 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8853 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
8862 if (!started_error_output
)
8864 started_error_output
= 1;
8865 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8867 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8871 break; /* Here to retransmit. */
8875 /* This is wrong. If doing a long backtrace, the user should be
8876 able to get out next time we call QUIT, without anything as
8877 violent as interrupt_query. If we want to provide a way out of
8878 here without getting to the next QUIT, it should be based on
8879 hitting ^C twice as in remote_wait. */
8888 do_cleanups (old_chain
);
8892 /* Come here after finding the start of a frame when we expected an
8893 ack. Do our best to discard the rest of this packet. */
8902 c
= readchar (remote_timeout
);
8905 case SERIAL_TIMEOUT
:
8906 /* Nothing we can do. */
8909 /* Discard the two bytes of checksum and stop. */
8910 c
= readchar (remote_timeout
);
8912 c
= readchar (remote_timeout
);
8915 case '*': /* Run length encoding. */
8916 /* Discard the repeat count. */
8917 c
= readchar (remote_timeout
);
8922 /* A regular character. */
8928 /* Come here after finding the start of the frame. Collect the rest
8929 into *BUF, verifying the checksum, length, and handling run-length
8930 compression. NUL terminate the buffer. If there is not enough room,
8931 expand *BUF using xrealloc.
8933 Returns -1 on error, number of characters in buffer (ignoring the
8934 trailing NULL) on success. (could be extended to return one of the
8935 SERIAL status indications). */
8938 read_frame (char **buf_p
,
8945 struct remote_state
*rs
= get_remote_state ();
8952 c
= readchar (remote_timeout
);
8955 case SERIAL_TIMEOUT
:
8957 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
8961 fputs_filtered ("Saw new packet start in middle of old one\n",
8963 return -1; /* Start a new packet, count retries. */
8966 unsigned char pktcsum
;
8972 check_0
= readchar (remote_timeout
);
8974 check_1
= readchar (remote_timeout
);
8976 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
8979 fputs_filtered ("Timeout in checksum, retrying\n",
8983 else if (check_0
< 0 || check_1
< 0)
8986 fputs_filtered ("Communication error in checksum\n",
8991 /* Don't recompute the checksum; with no ack packets we
8992 don't have any way to indicate a packet retransmission
8997 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
8998 if (csum
== pktcsum
)
9003 std::string str
= escape_buffer (buf
, bc
);
9005 fprintf_unfiltered (gdb_stdlog
,
9006 "Bad checksum, sentsum=0x%x, "
9007 "csum=0x%x, buf=%s\n",
9008 pktcsum
, csum
, str
.c_str ());
9010 /* Number of characters in buffer ignoring trailing
9014 case '*': /* Run length encoding. */
9019 c
= readchar (remote_timeout
);
9021 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9023 /* The character before ``*'' is repeated. */
9025 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9027 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
9029 /* Make some more room in the buffer. */
9030 *sizeof_buf
+= repeat
;
9031 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9035 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9041 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9045 if (bc
>= *sizeof_buf
- 1)
9047 /* Make some more room in the buffer. */
9049 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9060 /* Read a packet from the remote machine, with error checking, and
9061 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9062 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9063 rather than timing out; this is used (in synchronous mode) to wait
9064 for a target that is is executing user code to stop. */
9065 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9066 don't have to change all the calls to getpkt to deal with the
9067 return value, because at the moment I don't know what the right
9068 thing to do it for those. */
9074 getpkt_sane (buf
, sizeof_buf
, forever
);
9078 /* Read a packet from the remote machine, with error checking, and
9079 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9080 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9081 rather than timing out; this is used (in synchronous mode) to wait
9082 for a target that is is executing user code to stop. If FOREVER ==
9083 0, this function is allowed to time out gracefully and return an
9084 indication of this to the caller. Otherwise return the number of
9085 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9086 enough reason to return to the caller. *IS_NOTIF is an output
9087 boolean that indicates whether *BUF holds a notification or not
9088 (a regular packet). */
9091 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
9092 int expecting_notif
, int *is_notif
)
9094 struct remote_state
*rs
= get_remote_state ();
9100 /* We're reading a new response. Make sure we don't look at a
9101 previously cached response. */
9102 rs
->cached_wait_status
= 0;
9104 strcpy (*buf
, "timeout");
9107 timeout
= watchdog
> 0 ? watchdog
: -1;
9108 else if (expecting_notif
)
9109 timeout
= 0; /* There should already be a char in the buffer. If
9112 timeout
= remote_timeout
;
9116 /* Process any number of notifications, and then return when
9120 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9122 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9124 /* This can loop forever if the remote side sends us
9125 characters continuously, but if it pauses, we'll get
9126 SERIAL_TIMEOUT from readchar because of timeout. Then
9127 we'll count that as a retry.
9129 Note that even when forever is set, we will only wait
9130 forever prior to the start of a packet. After that, we
9131 expect characters to arrive at a brisk pace. They should
9132 show up within remote_timeout intervals. */
9134 c
= readchar (timeout
);
9135 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9137 if (c
== SERIAL_TIMEOUT
)
9139 if (expecting_notif
)
9140 return -1; /* Don't complain, it's normal to not get
9141 anything in this case. */
9143 if (forever
) /* Watchdog went off? Kill the target. */
9145 remote_unpush_target ();
9146 throw_error (TARGET_CLOSE_ERROR
,
9147 _("Watchdog timeout has expired. "
9148 "Target detached."));
9151 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9155 /* We've found the start of a packet or notification.
9156 Now collect the data. */
9157 val
= read_frame (buf
, sizeof_buf
);
9162 remote_serial_write ("-", 1);
9165 if (tries
> MAX_TRIES
)
9167 /* We have tried hard enough, and just can't receive the
9168 packet/notification. Give up. */
9169 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9171 /* Skip the ack char if we're in no-ack mode. */
9172 if (!rs
->noack_mode
)
9173 remote_serial_write ("+", 1);
9177 /* If we got an ordinary packet, return that to our caller. */
9182 std::string str
= escape_buffer (*buf
, val
);
9184 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s\n", str
.c_str ());
9187 /* Skip the ack char if we're in no-ack mode. */
9188 if (!rs
->noack_mode
)
9189 remote_serial_write ("+", 1);
9190 if (is_notif
!= NULL
)
9195 /* If we got a notification, handle it, and go back to looking
9199 gdb_assert (c
== '%');
9203 std::string str
= escape_buffer (*buf
, val
);
9205 fprintf_unfiltered (gdb_stdlog
,
9206 " Notification received: %s\n",
9209 if (is_notif
!= NULL
)
9212 handle_notification (rs
->notif_state
, *buf
);
9214 /* Notifications require no acknowledgement. */
9216 if (expecting_notif
)
9223 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
9225 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
9229 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
9232 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
9236 /* Check whether EVENT is a fork event for the process specified
9237 by the pid passed in DATA, and if it is, kill the fork child. */
9240 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
9241 QUEUE_ITER (stop_reply_p
) *iter
,
9245 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
9246 int parent_pid
= *(int *) param
->input
;
9248 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
9250 struct remote_state
*rs
= get_remote_state ();
9251 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
9254 res
= remote_vkill (child_pid
, rs
);
9256 error (_("Can't kill fork child process %d"), child_pid
);
9262 /* Kill any new fork children of process PID that haven't been
9263 processed by follow_fork. */
9266 kill_new_fork_children (int pid
, struct remote_state
*rs
)
9268 struct thread_info
*thread
;
9269 struct notif_client
*notif
= ¬if_client_stop
;
9270 struct queue_iter_param param
;
9272 /* Kill the fork child threads of any threads in process PID
9273 that are stopped at a fork event. */
9274 ALL_NON_EXITED_THREADS (thread
)
9276 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9278 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9280 struct remote_state
*rs
= get_remote_state ();
9281 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
9284 res
= remote_vkill (child_pid
, rs
);
9286 error (_("Can't kill fork child process %d"), child_pid
);
9290 /* Check for any pending fork events (not reported or processed yet)
9291 in process PID and kill those fork child threads as well. */
9292 remote_notif_get_pending_events (notif
);
9294 param
.output
= NULL
;
9295 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
9296 kill_child_of_pending_fork
, ¶m
);
9300 /* Target hook to kill the current inferior. */
9303 remote_kill (struct target_ops
*ops
)
9306 int pid
= ptid_get_pid (inferior_ptid
);
9307 struct remote_state
*rs
= get_remote_state ();
9309 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9311 /* If we're stopped while forking and we haven't followed yet,
9312 kill the child task. We need to do this before killing the
9313 parent task because if this is a vfork then the parent will
9315 kill_new_fork_children (pid
, rs
);
9317 res
= remote_vkill (pid
, rs
);
9320 target_mourn_inferior (inferior_ptid
);
9325 /* If we are in 'target remote' mode and we are killing the only
9326 inferior, then we will tell gdbserver to exit and unpush the
9328 if (res
== -1 && !remote_multi_process_p (rs
)
9329 && number_of_live_inferiors () == 1)
9333 /* We've killed the remote end, we get to mourn it. If we are
9334 not in extended mode, mourning the inferior also unpushes
9335 remote_ops from the target stack, which closes the remote
9337 target_mourn_inferior (inferior_ptid
);
9342 error (_("Can't kill process"));
9345 /* Send a kill request to the target using the 'vKill' packet. */
9348 remote_vkill (int pid
, struct remote_state
*rs
)
9350 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9353 /* Tell the remote target to detach. */
9354 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
9356 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9358 switch (packet_ok (rs
->buf
,
9359 &remote_protocol_packets
[PACKET_vKill
]))
9365 case PACKET_UNKNOWN
:
9368 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9372 /* Send a kill request to the target using the 'k' packet. */
9375 remote_kill_k (void)
9377 /* Catch errors so the user can quit from gdb even when we
9378 aren't on speaking terms with the remote system. */
9383 CATCH (ex
, RETURN_MASK_ERROR
)
9385 if (ex
.error
== TARGET_CLOSE_ERROR
)
9387 /* If we got an (EOF) error that caused the target
9388 to go away, then we're done, that's what we wanted.
9389 "k" is susceptible to cause a premature EOF, given
9390 that the remote server isn't actually required to
9391 reply to "k", and it can happen that it doesn't
9392 even get to reply ACK to the "k". */
9396 /* Otherwise, something went wrong. We didn't actually kill
9397 the target. Just propagate the exception, and let the
9398 user or higher layers decide what to do. */
9399 throw_exception (ex
);
9405 remote_mourn (struct target_ops
*target
)
9407 struct remote_state
*rs
= get_remote_state ();
9409 /* In 'target remote' mode with one inferior, we close the connection. */
9410 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9412 unpush_target (target
);
9414 /* remote_close takes care of doing most of the clean up. */
9415 generic_mourn_inferior ();
9419 /* In case we got here due to an error, but we're going to stay
9421 rs
->waiting_for_stop_reply
= 0;
9423 /* If the current general thread belonged to the process we just
9424 detached from or has exited, the remote side current general
9425 thread becomes undefined. Considering a case like this:
9427 - We just got here due to a detach.
9428 - The process that we're detaching from happens to immediately
9429 report a global breakpoint being hit in non-stop mode, in the
9430 same thread we had selected before.
9431 - GDB attaches to this process again.
9432 - This event happens to be the next event we handle.
9434 GDB would consider that the current general thread didn't need to
9435 be set on the stub side (with Hg), since for all it knew,
9436 GENERAL_THREAD hadn't changed.
9438 Notice that although in all-stop mode, the remote server always
9439 sets the current thread to the thread reporting the stop event,
9440 that doesn't happen in non-stop mode; in non-stop, the stub *must
9441 not* change the current thread when reporting a breakpoint hit,
9442 due to the decoupling of event reporting and event handling.
9444 To keep things simple, we always invalidate our notion of the
9446 record_currthread (rs
, minus_one_ptid
);
9448 /* Call common code to mark the inferior as not running. */
9449 generic_mourn_inferior ();
9451 if (!have_inferiors ())
9453 if (!remote_multi_process_p (rs
))
9455 /* Check whether the target is running now - some remote stubs
9456 automatically restart after kill. */
9458 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9460 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9462 /* Assume that the target has been restarted. Set
9463 inferior_ptid so that bits of core GDB realizes
9464 there's something here, e.g., so that the user can
9465 say "kill" again. */
9466 inferior_ptid
= magic_null_ptid
;
9473 extended_remote_supports_disable_randomization (struct target_ops
*self
)
9475 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9479 extended_remote_disable_randomization (int val
)
9481 struct remote_state
*rs
= get_remote_state ();
9484 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
9487 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9489 error (_("Target does not support QDisableRandomization."));
9490 if (strcmp (reply
, "OK") != 0)
9491 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9495 extended_remote_run (char *args
)
9497 struct remote_state
*rs
= get_remote_state ();
9499 const char *remote_exec_file
= get_remote_exec_file ();
9501 /* If the user has disabled vRun support, or we have detected that
9502 support is not available, do not try it. */
9503 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9506 strcpy (rs
->buf
, "vRun;");
9507 len
= strlen (rs
->buf
);
9509 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9510 error (_("Remote file name too long for run packet"));
9511 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
9512 strlen (remote_exec_file
));
9514 gdb_assert (args
!= NULL
);
9517 struct cleanup
*back_to
;
9521 argv
= gdb_buildargv (args
);
9522 back_to
= make_cleanup_freeargv (argv
);
9523 for (i
= 0; argv
[i
] != NULL
; i
++)
9525 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9526 error (_("Argument list too long for run packet"));
9527 rs
->buf
[len
++] = ';';
9528 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
9531 do_cleanups (back_to
);
9534 rs
->buf
[len
++] = '\0';
9537 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9539 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9542 /* We have a wait response. All is well. */
9544 case PACKET_UNKNOWN
:
9547 if (remote_exec_file
[0] == '\0')
9548 error (_("Running the default executable on the remote target failed; "
9549 "try \"set remote exec-file\"?"));
9551 error (_("Running \"%s\" on the remote target failed"),
9554 gdb_assert_not_reached (_("bad switch"));
9558 /* In the extended protocol we want to be able to do things like
9559 "run" and have them basically work as expected. So we need
9560 a special create_inferior function. We support changing the
9561 executable file and the command line arguments, but not the
9565 extended_remote_create_inferior (struct target_ops
*ops
,
9566 char *exec_file
, char *args
,
9567 char **env
, int from_tty
)
9571 struct remote_state
*rs
= get_remote_state ();
9572 const char *remote_exec_file
= get_remote_exec_file ();
9574 /* If running asynchronously, register the target file descriptor
9575 with the event loop. */
9576 if (target_can_async_p ())
9579 /* Disable address space randomization if requested (and supported). */
9580 if (extended_remote_supports_disable_randomization (ops
))
9581 extended_remote_disable_randomization (disable_randomization
);
9583 /* Now restart the remote server. */
9584 run_worked
= extended_remote_run (args
) != -1;
9587 /* vRun was not supported. Fail if we need it to do what the
9589 if (remote_exec_file
[0])
9590 error (_("Remote target does not support \"set remote exec-file\""));
9592 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9594 /* Fall back to "R". */
9595 extended_remote_restart ();
9598 if (!have_inferiors ())
9600 /* Clean up from the last time we ran, before we mark the target
9601 running again. This will mark breakpoints uninserted, and
9602 get_offsets may insert breakpoints. */
9603 init_thread_list ();
9604 init_wait_for_inferior ();
9607 /* vRun's success return is a stop reply. */
9608 stop_reply
= run_worked
? rs
->buf
: NULL
;
9609 add_current_inferior_and_thread (stop_reply
);
9611 /* Get updated offsets, if the stub uses qOffsets. */
9616 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9617 the list of conditions (in agent expression bytecode format), if any, the
9618 target needs to evaluate. The output is placed into the packet buffer
9619 started from BUF and ended at BUF_END. */
9622 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
9623 struct bp_target_info
*bp_tgt
, char *buf
,
9626 if (bp_tgt
->conditions
.empty ())
9629 buf
+= strlen (buf
);
9630 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
9633 /* Send conditions to the target and free the vector. */
9634 for (int ix
= 0; ix
< bp_tgt
->conditions
.size (); ix
++)
9636 struct agent_expr
*aexpr
= bp_tgt
->conditions
[ix
];
9638 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
9639 buf
+= strlen (buf
);
9640 for (int i
= 0; i
< aexpr
->len
; ++i
)
9641 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9648 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
9649 struct bp_target_info
*bp_tgt
, char *buf
)
9651 if (bp_tgt
->tcommands
.empty ())
9654 buf
+= strlen (buf
);
9656 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
9657 buf
+= strlen (buf
);
9659 /* Concatenate all the agent expressions that are commands into the
9661 for (int ix
= 0; ix
< bp_tgt
->tcommands
.size (); ix
++)
9663 struct agent_expr
*aexpr
= bp_tgt
->tcommands
[ix
];
9665 sprintf (buf
, "X%x,", aexpr
->len
);
9666 buf
+= strlen (buf
);
9667 for (int i
= 0; i
< aexpr
->len
; ++i
)
9668 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9673 /* Insert a breakpoint. On targets that have software breakpoint
9674 support, we ask the remote target to do the work; on targets
9675 which don't, we insert a traditional memory breakpoint. */
9678 remote_insert_breakpoint (struct target_ops
*ops
,
9679 struct gdbarch
*gdbarch
,
9680 struct bp_target_info
*bp_tgt
)
9682 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9683 If it succeeds, then set the support to PACKET_ENABLE. If it
9684 fails, and the user has explicitly requested the Z support then
9685 report an error, otherwise, mark it disabled and go on. */
9687 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9689 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9690 struct remote_state
*rs
;
9694 /* Make sure the remote is pointing at the right process, if
9696 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9697 set_general_process ();
9699 rs
= get_remote_state ();
9701 endbuf
= rs
->buf
+ get_remote_packet_size ();
9706 addr
= (ULONGEST
) remote_address_masked (addr
);
9707 p
+= hexnumstr (p
, addr
);
9708 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9710 if (remote_supports_cond_breakpoints (ops
))
9711 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
9713 if (remote_can_run_breakpoint_commands (ops
))
9714 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
9717 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9719 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
9725 case PACKET_UNKNOWN
:
9730 /* If this breakpoint has target-side commands but this stub doesn't
9731 support Z0 packets, throw error. */
9732 if (!bp_tgt
->tcommands
.empty ())
9733 throw_error (NOT_SUPPORTED_ERROR
, _("\
9734 Target doesn't support breakpoints that have target side commands."));
9736 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
9740 remote_remove_breakpoint (struct target_ops
*ops
,
9741 struct gdbarch
*gdbarch
,
9742 struct bp_target_info
*bp_tgt
,
9743 enum remove_bp_reason reason
)
9745 CORE_ADDR addr
= bp_tgt
->placed_address
;
9746 struct remote_state
*rs
= get_remote_state ();
9748 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9751 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9753 /* Make sure the remote is pointing at the right process, if
9755 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9756 set_general_process ();
9762 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
9763 p
+= hexnumstr (p
, addr
);
9764 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9767 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9769 return (rs
->buf
[0] == 'E');
9772 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
, reason
);
9775 static enum Z_packet_type
9776 watchpoint_to_Z_packet (int type
)
9781 return Z_PACKET_WRITE_WP
;
9784 return Z_PACKET_READ_WP
;
9787 return Z_PACKET_ACCESS_WP
;
9790 internal_error (__FILE__
, __LINE__
,
9791 _("hw_bp_to_z: bad watchpoint type %d"), type
);
9796 remote_insert_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9797 enum target_hw_bp_type type
, struct expression
*cond
)
9799 struct remote_state
*rs
= get_remote_state ();
9800 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9802 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9804 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9807 /* Make sure the remote is pointing at the right process, if
9809 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9810 set_general_process ();
9812 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
9813 p
= strchr (rs
->buf
, '\0');
9814 addr
= remote_address_masked (addr
);
9815 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9816 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9819 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9821 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9825 case PACKET_UNKNOWN
:
9830 internal_error (__FILE__
, __LINE__
,
9831 _("remote_insert_watchpoint: reached end of function"));
9835 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
9836 CORE_ADDR start
, int length
)
9838 CORE_ADDR diff
= remote_address_masked (addr
- start
);
9840 return diff
< length
;
9845 remote_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9846 enum target_hw_bp_type type
, struct expression
*cond
)
9848 struct remote_state
*rs
= get_remote_state ();
9849 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9851 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9853 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9856 /* Make sure the remote is pointing at the right process, if
9858 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9859 set_general_process ();
9861 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
9862 p
= strchr (rs
->buf
, '\0');
9863 addr
= remote_address_masked (addr
);
9864 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9865 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9867 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9869 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9872 case PACKET_UNKNOWN
:
9877 internal_error (__FILE__
, __LINE__
,
9878 _("remote_remove_watchpoint: reached end of function"));
9882 int remote_hw_watchpoint_limit
= -1;
9883 int remote_hw_watchpoint_length_limit
= -1;
9884 int remote_hw_breakpoint_limit
= -1;
9887 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
9888 CORE_ADDR addr
, int len
)
9890 if (remote_hw_watchpoint_length_limit
== 0)
9892 else if (remote_hw_watchpoint_length_limit
< 0)
9894 else if (len
<= remote_hw_watchpoint_length_limit
)
9901 remote_check_watch_resources (struct target_ops
*self
,
9902 enum bptype type
, int cnt
, int ot
)
9904 if (type
== bp_hardware_breakpoint
)
9906 if (remote_hw_breakpoint_limit
== 0)
9908 else if (remote_hw_breakpoint_limit
< 0)
9910 else if (cnt
<= remote_hw_breakpoint_limit
)
9915 if (remote_hw_watchpoint_limit
== 0)
9917 else if (remote_hw_watchpoint_limit
< 0)
9921 else if (cnt
<= remote_hw_watchpoint_limit
)
9927 /* The to_stopped_by_sw_breakpoint method of target remote. */
9930 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9932 struct thread_info
*thread
= inferior_thread ();
9934 return (thread
->priv
!= NULL
9935 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
9938 /* The to_supports_stopped_by_sw_breakpoint method of target
9942 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
9944 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
9947 /* The to_stopped_by_hw_breakpoint method of target remote. */
9950 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
9952 struct thread_info
*thread
= inferior_thread ();
9954 return (thread
->priv
!= NULL
9955 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
9958 /* The to_supports_stopped_by_hw_breakpoint method of target
9962 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
9964 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
9968 remote_stopped_by_watchpoint (struct target_ops
*ops
)
9970 struct thread_info
*thread
= inferior_thread ();
9972 return (thread
->priv
!= NULL
9973 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
);
9977 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
9979 struct thread_info
*thread
= inferior_thread ();
9981 if (thread
->priv
!= NULL
9982 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
9984 *addr_p
= thread
->priv
->watch_data_address
;
9993 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
9994 struct bp_target_info
*bp_tgt
)
9996 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9997 struct remote_state
*rs
;
10001 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10004 /* Make sure the remote is pointing at the right process, if
10006 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10007 set_general_process ();
10009 rs
= get_remote_state ();
10011 endbuf
= rs
->buf
+ get_remote_packet_size ();
10017 addr
= remote_address_masked (addr
);
10018 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10019 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10021 if (remote_supports_cond_breakpoints (self
))
10022 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10024 if (remote_can_run_breakpoint_commands (self
))
10025 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10028 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10030 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10033 if (rs
->buf
[1] == '.')
10035 message
= strchr (rs
->buf
+ 2, '.');
10037 error (_("Remote failure reply: %s"), message
+ 1);
10040 case PACKET_UNKNOWN
:
10045 internal_error (__FILE__
, __LINE__
,
10046 _("remote_insert_hw_breakpoint: reached end of function"));
10051 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10052 struct bp_target_info
*bp_tgt
)
10055 struct remote_state
*rs
= get_remote_state ();
10057 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
10059 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10062 /* Make sure the remote is pointing at the right process, if
10064 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10065 set_general_process ();
10071 addr
= remote_address_masked (bp_tgt
->placed_address
);
10072 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10073 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10076 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10078 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10081 case PACKET_UNKNOWN
:
10086 internal_error (__FILE__
, __LINE__
,
10087 _("remote_remove_hw_breakpoint: reached end of function"));
10090 /* Verify memory using the "qCRC:" request. */
10093 remote_verify_memory (struct target_ops
*ops
,
10094 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10096 struct remote_state
*rs
= get_remote_state ();
10097 unsigned long host_crc
, target_crc
;
10100 /* It doesn't make sense to use qCRC if the remote target is
10101 connected but not running. */
10102 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10104 enum packet_result result
;
10106 /* Make sure the remote is pointing at the right process. */
10107 set_general_process ();
10109 /* FIXME: assumes lma can fit into long. */
10110 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
10111 (long) lma
, (long) size
);
10114 /* Be clever; compute the host_crc before waiting for target
10116 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10118 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10120 result
= packet_ok (rs
->buf
,
10121 &remote_protocol_packets
[PACKET_qCRC
]);
10122 if (result
== PACKET_ERROR
)
10124 else if (result
== PACKET_OK
)
10126 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10127 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10129 return (host_crc
== target_crc
);
10133 return simple_verify_memory (ops
, data
, lma
, size
);
10136 /* compare-sections command
10138 With no arguments, compares each loadable section in the exec bfd
10139 with the same memory range on the target, and reports mismatches.
10140 Useful for verifying the image on the target against the exec file. */
10143 compare_sections_command (char *args
, int from_tty
)
10146 struct cleanup
*old_chain
;
10147 gdb_byte
*sectdata
;
10148 const char *sectname
;
10149 bfd_size_type size
;
10152 int mismatched
= 0;
10157 error (_("command cannot be used without an exec file"));
10159 /* Make sure the remote is pointing at the right process. */
10160 set_general_process ();
10162 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10168 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10170 if (!(s
->flags
& SEC_LOAD
))
10171 continue; /* Skip non-loadable section. */
10173 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10174 continue; /* Skip writeable sections */
10176 size
= bfd_get_section_size (s
);
10178 continue; /* Skip zero-length section. */
10180 sectname
= bfd_get_section_name (exec_bfd
, s
);
10181 if (args
&& strcmp (args
, sectname
) != 0)
10182 continue; /* Not the section selected by user. */
10184 matched
= 1; /* Do this section. */
10187 sectdata
= (gdb_byte
*) xmalloc (size
);
10188 old_chain
= make_cleanup (xfree
, sectdata
);
10189 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
10191 res
= target_verify_memory (sectdata
, lma
, size
);
10194 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10195 paddress (target_gdbarch (), lma
),
10196 paddress (target_gdbarch (), lma
+ size
));
10198 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10199 paddress (target_gdbarch (), lma
),
10200 paddress (target_gdbarch (), lma
+ size
));
10202 printf_filtered ("matched.\n");
10205 printf_filtered ("MIS-MATCHED!\n");
10209 do_cleanups (old_chain
);
10211 if (mismatched
> 0)
10212 warning (_("One or more sections of the target image does not match\n\
10213 the loaded file\n"));
10214 if (args
&& !matched
)
10215 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10218 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10219 into remote target. The number of bytes written to the remote
10220 target is returned, or -1 for error. */
10222 static enum target_xfer_status
10223 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
10224 const char *annex
, const gdb_byte
*writebuf
,
10225 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
10226 struct packet_config
*packet
)
10230 struct remote_state
*rs
= get_remote_state ();
10231 int max_size
= get_memory_write_packet_size ();
10233 if (packet
->support
== PACKET_DISABLE
)
10234 return TARGET_XFER_E_IO
;
10236 /* Insert header. */
10237 i
= snprintf (rs
->buf
, max_size
,
10238 "qXfer:%s:write:%s:%s:",
10239 object_name
, annex
? annex
: "",
10240 phex_nz (offset
, sizeof offset
));
10241 max_size
-= (i
+ 1);
10243 /* Escape as much data as fits into rs->buf. */
10244 buf_len
= remote_escape_output
10245 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
10247 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
10248 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10249 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10250 return TARGET_XFER_E_IO
;
10252 unpack_varlen_hex (rs
->buf
, &n
);
10255 return TARGET_XFER_OK
;
10258 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10259 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10260 number of bytes read is returned, or 0 for EOF, or -1 for error.
10261 The number of bytes read may be less than LEN without indicating an
10262 EOF. PACKET is checked and updated to indicate whether the remote
10263 target supports this object. */
10265 static enum target_xfer_status
10266 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
10268 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
10269 ULONGEST
*xfered_len
,
10270 struct packet_config
*packet
)
10272 struct remote_state
*rs
= get_remote_state ();
10273 LONGEST i
, n
, packet_len
;
10275 if (packet
->support
== PACKET_DISABLE
)
10276 return TARGET_XFER_E_IO
;
10278 /* Check whether we've cached an end-of-object packet that matches
10280 if (rs
->finished_object
)
10282 if (strcmp (object_name
, rs
->finished_object
) == 0
10283 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10284 && offset
== rs
->finished_offset
)
10285 return TARGET_XFER_EOF
;
10288 /* Otherwise, we're now reading something different. Discard
10290 xfree (rs
->finished_object
);
10291 xfree (rs
->finished_annex
);
10292 rs
->finished_object
= NULL
;
10293 rs
->finished_annex
= NULL
;
10296 /* Request only enough to fit in a single packet. The actual data
10297 may not, since we don't know how much of it will need to be escaped;
10298 the target is free to respond with slightly less data. We subtract
10299 five to account for the response type and the protocol frame. */
10300 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10301 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10302 object_name
, annex
? annex
: "",
10303 phex_nz (offset
, sizeof offset
),
10304 phex_nz (n
, sizeof n
));
10305 i
= putpkt (rs
->buf
);
10307 return TARGET_XFER_E_IO
;
10310 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10311 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10312 return TARGET_XFER_E_IO
;
10314 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10315 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
10317 /* 'm' means there is (or at least might be) more data after this
10318 batch. That does not make sense unless there's at least one byte
10319 of data in this reply. */
10320 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10321 error (_("Remote qXfer reply contained no data."));
10323 /* Got some data. */
10324 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
10325 packet_len
- 1, readbuf
, n
);
10327 /* 'l' is an EOF marker, possibly including a final block of data,
10328 or possibly empty. If we have the final block of a non-empty
10329 object, record this fact to bypass a subsequent partial read. */
10330 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10332 rs
->finished_object
= xstrdup (object_name
);
10333 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10334 rs
->finished_offset
= offset
+ i
;
10338 return TARGET_XFER_EOF
;
10342 return TARGET_XFER_OK
;
10346 static enum target_xfer_status
10347 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
10348 const char *annex
, gdb_byte
*readbuf
,
10349 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10350 ULONGEST
*xfered_len
)
10352 struct remote_state
*rs
;
10356 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10358 set_remote_traceframe ();
10359 set_general_thread (inferior_ptid
);
10361 rs
= get_remote_state ();
10363 /* Handle memory using the standard memory routines. */
10364 if (object
== TARGET_OBJECT_MEMORY
)
10366 /* If the remote target is connected but not running, we should
10367 pass this request down to a lower stratum (e.g. the executable
10369 if (!target_has_execution
)
10370 return TARGET_XFER_EOF
;
10372 if (writebuf
!= NULL
)
10373 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10376 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
10380 /* Handle SPU memory using qxfer packets. */
10381 if (object
== TARGET_OBJECT_SPU
)
10384 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
10385 xfered_len
, &remote_protocol_packets
10386 [PACKET_qXfer_spu_read
]);
10388 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
10389 xfered_len
, &remote_protocol_packets
10390 [PACKET_qXfer_spu_write
]);
10393 /* Handle extra signal info using qxfer packets. */
10394 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10397 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
10398 xfered_len
, &remote_protocol_packets
10399 [PACKET_qXfer_siginfo_read
]);
10401 return remote_write_qxfer (ops
, "siginfo", annex
,
10402 writebuf
, offset
, len
, xfered_len
,
10403 &remote_protocol_packets
10404 [PACKET_qXfer_siginfo_write
]);
10407 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10410 return remote_read_qxfer (ops
, "statictrace", annex
,
10411 readbuf
, offset
, len
, xfered_len
,
10412 &remote_protocol_packets
10413 [PACKET_qXfer_statictrace_read
]);
10415 return TARGET_XFER_E_IO
;
10418 /* Only handle flash writes. */
10419 if (writebuf
!= NULL
)
10423 case TARGET_OBJECT_FLASH
:
10424 return remote_flash_write (ops
, offset
, len
, xfered_len
,
10428 return TARGET_XFER_E_IO
;
10432 /* Map pre-existing objects onto letters. DO NOT do this for new
10433 objects!!! Instead specify new query packets. */
10436 case TARGET_OBJECT_AVR
:
10440 case TARGET_OBJECT_AUXV
:
10441 gdb_assert (annex
== NULL
);
10442 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
10444 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10446 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10447 return remote_read_qxfer
10448 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
10449 &remote_protocol_packets
[PACKET_qXfer_features
]);
10451 case TARGET_OBJECT_LIBRARIES
:
10452 return remote_read_qxfer
10453 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10454 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10456 case TARGET_OBJECT_LIBRARIES_SVR4
:
10457 return remote_read_qxfer
10458 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10459 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10461 case TARGET_OBJECT_MEMORY_MAP
:
10462 gdb_assert (annex
== NULL
);
10463 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
10465 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10467 case TARGET_OBJECT_OSDATA
:
10468 /* Should only get here if we're connected. */
10469 gdb_assert (rs
->remote_desc
);
10470 return remote_read_qxfer
10471 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10472 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10474 case TARGET_OBJECT_THREADS
:
10475 gdb_assert (annex
== NULL
);
10476 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
10478 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10480 case TARGET_OBJECT_TRACEFRAME_INFO
:
10481 gdb_assert (annex
== NULL
);
10482 return remote_read_qxfer
10483 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10484 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10486 case TARGET_OBJECT_FDPIC
:
10487 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
10489 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10491 case TARGET_OBJECT_OPENVMS_UIB
:
10492 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
10494 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10496 case TARGET_OBJECT_BTRACE
:
10497 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
10499 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10501 case TARGET_OBJECT_BTRACE_CONF
:
10502 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
10504 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10506 case TARGET_OBJECT_EXEC_FILE
:
10507 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
10509 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10512 return TARGET_XFER_E_IO
;
10515 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10516 large enough let the caller deal with it. */
10517 if (len
< get_remote_packet_size ())
10518 return TARGET_XFER_E_IO
;
10519 len
= get_remote_packet_size ();
10521 /* Except for querying the minimum buffer size, target must be open. */
10522 if (!rs
->remote_desc
)
10523 error (_("remote query is only available after target open"));
10525 gdb_assert (annex
!= NULL
);
10526 gdb_assert (readbuf
!= NULL
);
10530 *p2
++ = query_type
;
10532 /* We used one buffer char for the remote protocol q command and
10533 another for the query type. As the remote protocol encapsulation
10534 uses 4 chars plus one extra in case we are debugging
10535 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10538 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10540 /* Bad caller may have sent forbidden characters. */
10541 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10546 gdb_assert (annex
[i
] == '\0');
10548 i
= putpkt (rs
->buf
);
10550 return TARGET_XFER_E_IO
;
10552 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10553 strcpy ((char *) readbuf
, rs
->buf
);
10555 *xfered_len
= strlen ((char *) readbuf
);
10556 return TARGET_XFER_OK
;
10559 /* Implementation of to_get_memory_xfer_limit. */
10562 remote_get_memory_xfer_limit (struct target_ops
*ops
)
10564 return get_memory_write_packet_size ();
10568 remote_search_memory (struct target_ops
* ops
,
10569 CORE_ADDR start_addr
, ULONGEST search_space_len
,
10570 const gdb_byte
*pattern
, ULONGEST pattern_len
,
10571 CORE_ADDR
*found_addrp
)
10573 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
10574 struct remote_state
*rs
= get_remote_state ();
10575 int max_size
= get_memory_write_packet_size ();
10576 struct packet_config
*packet
=
10577 &remote_protocol_packets
[PACKET_qSearch_memory
];
10578 /* Number of packet bytes used to encode the pattern;
10579 this could be more than PATTERN_LEN due to escape characters. */
10580 int escaped_pattern_len
;
10581 /* Amount of pattern that was encodable in the packet. */
10582 int used_pattern_len
;
10585 ULONGEST found_addr
;
10587 /* Don't go to the target if we don't have to.
10588 This is done before checking packet->support to avoid the possibility that
10589 a success for this edge case means the facility works in general. */
10590 if (pattern_len
> search_space_len
)
10592 if (pattern_len
== 0)
10594 *found_addrp
= start_addr
;
10598 /* If we already know the packet isn't supported, fall back to the simple
10599 way of searching memory. */
10601 if (packet_config_support (packet
) == PACKET_DISABLE
)
10603 /* Target doesn't provided special support, fall back and use the
10604 standard support (copy memory and do the search here). */
10605 return simple_search_memory (ops
, start_addr
, search_space_len
,
10606 pattern
, pattern_len
, found_addrp
);
10609 /* Make sure the remote is pointing at the right process. */
10610 set_general_process ();
10612 /* Insert header. */
10613 i
= snprintf (rs
->buf
, max_size
,
10614 "qSearch:memory:%s;%s;",
10615 phex_nz (start_addr
, addr_size
),
10616 phex_nz (search_space_len
, sizeof (search_space_len
)));
10617 max_size
-= (i
+ 1);
10619 /* Escape as much data as fits into rs->buf. */
10620 escaped_pattern_len
=
10621 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
10622 &used_pattern_len
, max_size
);
10624 /* Bail if the pattern is too large. */
10625 if (used_pattern_len
!= pattern_len
)
10626 error (_("Pattern is too large to transmit to remote target."));
10628 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
10629 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10630 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10632 /* The request may not have worked because the command is not
10633 supported. If so, fall back to the simple way. */
10634 if (packet
->support
== PACKET_DISABLE
)
10636 return simple_search_memory (ops
, start_addr
, search_space_len
,
10637 pattern
, pattern_len
, found_addrp
);
10642 if (rs
->buf
[0] == '0')
10644 else if (rs
->buf
[0] == '1')
10647 if (rs
->buf
[1] != ',')
10648 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10649 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
10650 *found_addrp
= found_addr
;
10653 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10659 remote_rcmd (struct target_ops
*self
, const char *command
,
10660 struct ui_file
*outbuf
)
10662 struct remote_state
*rs
= get_remote_state ();
10665 if (!rs
->remote_desc
)
10666 error (_("remote rcmd is only available after target open"));
10668 /* Send a NULL command across as an empty command. */
10669 if (command
== NULL
)
10672 /* The query prefix. */
10673 strcpy (rs
->buf
, "qRcmd,");
10674 p
= strchr (rs
->buf
, '\0');
10676 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
10677 > get_remote_packet_size ())
10678 error (_("\"monitor\" command ``%s'' is too long."), command
);
10680 /* Encode the actual command. */
10681 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
10683 if (putpkt (rs
->buf
) < 0)
10684 error (_("Communication problem with target."));
10686 /* get/display the response */
10691 /* XXX - see also remote_get_noisy_reply(). */
10692 QUIT
; /* Allow user to bail out with ^C. */
10694 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
10696 /* Timeout. Continue to (try to) read responses.
10697 This is better than stopping with an error, assuming the stub
10698 is still executing the (long) monitor command.
10699 If needed, the user can interrupt gdb using C-c, obtaining
10700 an effect similar to stop on timeout. */
10704 if (buf
[0] == '\0')
10705 error (_("Target does not support this command."));
10706 if (buf
[0] == 'O' && buf
[1] != 'K')
10708 remote_console_output (buf
+ 1); /* 'O' message from stub. */
10711 if (strcmp (buf
, "OK") == 0)
10713 if (strlen (buf
) == 3 && buf
[0] == 'E'
10714 && isdigit (buf
[1]) && isdigit (buf
[2]))
10716 error (_("Protocol error with Rcmd"));
10718 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
10720 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
10722 fputc_unfiltered (c
, outbuf
);
10728 static VEC(mem_region_s
) *
10729 remote_memory_map (struct target_ops
*ops
)
10731 VEC(mem_region_s
) *result
= NULL
;
10732 char *text
= target_read_stralloc (¤t_target
,
10733 TARGET_OBJECT_MEMORY_MAP
, NULL
);
10737 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
10739 result
= parse_memory_map (text
);
10740 do_cleanups (back_to
);
10747 packet_command (char *args
, int from_tty
)
10749 struct remote_state
*rs
= get_remote_state ();
10751 if (!rs
->remote_desc
)
10752 error (_("command can only be used with remote target"));
10755 error (_("remote-packet command requires packet text as argument"));
10757 puts_filtered ("sending: ");
10758 print_packet (args
);
10759 puts_filtered ("\n");
10762 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10763 puts_filtered ("received: ");
10764 print_packet (rs
->buf
);
10765 puts_filtered ("\n");
10769 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10771 static void display_thread_info (struct gdb_ext_thread_info
*info
);
10773 static void threadset_test_cmd (char *cmd
, int tty
);
10775 static void threadalive_test (char *cmd
, int tty
);
10777 static void threadlist_test_cmd (char *cmd
, int tty
);
10779 int get_and_display_threadinfo (threadref
*ref
);
10781 static void threadinfo_test_cmd (char *cmd
, int tty
);
10783 static int thread_display_step (threadref
*ref
, void *context
);
10785 static void threadlist_update_test_cmd (char *cmd
, int tty
);
10787 static void init_remote_threadtests (void);
10789 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10792 threadset_test_cmd (char *cmd
, int tty
)
10794 int sample_thread
= SAMPLE_THREAD
;
10796 printf_filtered (_("Remote threadset test\n"));
10797 set_general_thread (sample_thread
);
10802 threadalive_test (char *cmd
, int tty
)
10804 int sample_thread
= SAMPLE_THREAD
;
10805 int pid
= ptid_get_pid (inferior_ptid
);
10806 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
10808 if (remote_thread_alive (ptid
))
10809 printf_filtered ("PASS: Thread alive test\n");
10811 printf_filtered ("FAIL: Thread alive test\n");
10814 void output_threadid (char *title
, threadref
*ref
);
10817 output_threadid (char *title
, threadref
*ref
)
10821 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
10823 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
10827 threadlist_test_cmd (char *cmd
, int tty
)
10830 threadref nextthread
;
10831 int done
, result_count
;
10832 threadref threadlist
[3];
10834 printf_filtered ("Remote Threadlist test\n");
10835 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
10836 &result_count
, &threadlist
[0]))
10837 printf_filtered ("FAIL: threadlist test\n");
10840 threadref
*scan
= threadlist
;
10841 threadref
*limit
= scan
+ result_count
;
10843 while (scan
< limit
)
10844 output_threadid (" thread ", scan
++);
10849 display_thread_info (struct gdb_ext_thread_info
*info
)
10851 output_threadid ("Threadid: ", &info
->threadid
);
10852 printf_filtered ("Name: %s\n ", info
->shortname
);
10853 printf_filtered ("State: %s\n", info
->display
);
10854 printf_filtered ("other: %s\n\n", info
->more_display
);
10858 get_and_display_threadinfo (threadref
*ref
)
10862 struct gdb_ext_thread_info threadinfo
;
10864 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
10865 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
10866 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
10867 display_thread_info (&threadinfo
);
10872 threadinfo_test_cmd (char *cmd
, int tty
)
10874 int athread
= SAMPLE_THREAD
;
10878 int_to_threadref (&thread
, athread
);
10879 printf_filtered ("Remote Threadinfo test\n");
10880 if (!get_and_display_threadinfo (&thread
))
10881 printf_filtered ("FAIL cannot get thread info\n");
10885 thread_display_step (threadref
*ref
, void *context
)
10887 /* output_threadid(" threadstep ",ref); *//* simple test */
10888 return get_and_display_threadinfo (ref
);
10892 threadlist_update_test_cmd (char *cmd
, int tty
)
10894 printf_filtered ("Remote Threadlist update test\n");
10895 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
10899 init_remote_threadtests (void)
10901 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
10902 _("Fetch and print the remote list of "
10903 "thread identifiers, one pkt only"));
10904 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
10905 _("Fetch and display info about one thread"));
10906 add_com ("tset", class_obscure
, threadset_test_cmd
,
10907 _("Test setting to a different thread"));
10908 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
10909 _("Iterate through updating all remote thread info"));
10910 add_com ("talive", class_obscure
, threadalive_test
,
10911 _(" Remote thread alive test "));
10916 /* Convert a thread ID to a string. Returns the string in a static
10920 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
10922 static char buf
[64];
10923 struct remote_state
*rs
= get_remote_state ();
10925 if (ptid_equal (ptid
, null_ptid
))
10926 return normal_pid_to_str (ptid
);
10927 else if (ptid_is_pid (ptid
))
10929 /* Printing an inferior target id. */
10931 /* When multi-process extensions are off, there's no way in the
10932 remote protocol to know the remote process id, if there's any
10933 at all. There's one exception --- when we're connected with
10934 target extended-remote, and we manually attached to a process
10935 with "attach PID". We don't record anywhere a flag that
10936 allows us to distinguish that case from the case of
10937 connecting with extended-remote and the stub already being
10938 attached to a process, and reporting yes to qAttached, hence
10939 no smart special casing here. */
10940 if (!remote_multi_process_p (rs
))
10942 xsnprintf (buf
, sizeof buf
, "Remote target");
10946 return normal_pid_to_str (ptid
);
10950 if (ptid_equal (magic_null_ptid
, ptid
))
10951 xsnprintf (buf
, sizeof buf
, "Thread <main>");
10952 else if (remote_multi_process_p (rs
))
10953 if (ptid_get_lwp (ptid
) == 0)
10954 return normal_pid_to_str (ptid
);
10956 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
10957 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
10959 xsnprintf (buf
, sizeof buf
, "Thread %ld",
10960 ptid_get_lwp (ptid
));
10965 /* Get the address of the thread local variable in OBJFILE which is
10966 stored at OFFSET within the thread local storage for thread PTID. */
10969 remote_get_thread_local_address (struct target_ops
*ops
,
10970 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
10972 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
10974 struct remote_state
*rs
= get_remote_state ();
10976 char *endp
= rs
->buf
+ get_remote_packet_size ();
10977 enum packet_result result
;
10979 strcpy (p
, "qGetTLSAddr:");
10981 p
= write_ptid (p
, endp
, ptid
);
10983 p
+= hexnumstr (p
, offset
);
10985 p
+= hexnumstr (p
, lm
);
10989 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10990 result
= packet_ok (rs
->buf
,
10991 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
10992 if (result
== PACKET_OK
)
10996 unpack_varlen_hex (rs
->buf
, &result
);
10999 else if (result
== PACKET_UNKNOWN
)
11000 throw_error (TLS_GENERIC_ERROR
,
11001 _("Remote target doesn't support qGetTLSAddr packet"));
11003 throw_error (TLS_GENERIC_ERROR
,
11004 _("Remote target failed to process qGetTLSAddr request"));
11007 throw_error (TLS_GENERIC_ERROR
,
11008 _("TLS not supported or disabled on this target"));
11013 /* Provide thread local base, i.e. Thread Information Block address.
11014 Returns 1 if ptid is found and thread_local_base is non zero. */
11017 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
11019 if (packet_support (PACKET_qGetTIBAddr
) != 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
, "qGetTIBAddr:");
11028 p
= write_ptid (p
, endp
, ptid
);
11032 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11033 result
= packet_ok (rs
->buf
,
11034 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11035 if (result
== PACKET_OK
)
11039 unpack_varlen_hex (rs
->buf
, &result
);
11041 *addr
= (CORE_ADDR
) result
;
11044 else if (result
== PACKET_UNKNOWN
)
11045 error (_("Remote target doesn't support qGetTIBAddr packet"));
11047 error (_("Remote target failed to process qGetTIBAddr request"));
11050 error (_("qGetTIBAddr not supported or disabled on this target"));
11055 /* Support for inferring a target description based on the current
11056 architecture and the size of a 'g' packet. While the 'g' packet
11057 can have any size (since optional registers can be left off the
11058 end), some sizes are easily recognizable given knowledge of the
11059 approximate architecture. */
11061 struct remote_g_packet_guess
11064 const struct target_desc
*tdesc
;
11066 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
11067 DEF_VEC_O(remote_g_packet_guess_s
);
11069 struct remote_g_packet_data
11071 VEC(remote_g_packet_guess_s
) *guesses
;
11074 static struct gdbarch_data
*remote_g_packet_data_handle
;
11077 remote_g_packet_data_init (struct obstack
*obstack
)
11079 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
11083 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11084 const struct target_desc
*tdesc
)
11086 struct remote_g_packet_data
*data
11087 = ((struct remote_g_packet_data
*)
11088 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11089 struct remote_g_packet_guess new_guess
, *guess
;
11092 gdb_assert (tdesc
!= NULL
);
11095 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11097 if (guess
->bytes
== bytes
)
11098 internal_error (__FILE__
, __LINE__
,
11099 _("Duplicate g packet description added for size %d"),
11102 new_guess
.bytes
= bytes
;
11103 new_guess
.tdesc
= tdesc
;
11104 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
11107 /* Return 1 if remote_read_description would do anything on this target
11108 and architecture, 0 otherwise. */
11111 remote_read_description_p (struct target_ops
*target
)
11113 struct remote_g_packet_data
*data
11114 = ((struct remote_g_packet_data
*)
11115 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11117 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11123 static const struct target_desc
*
11124 remote_read_description (struct target_ops
*target
)
11126 struct remote_g_packet_data
*data
11127 = ((struct remote_g_packet_data
*)
11128 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11130 /* Do not try this during initial connection, when we do not know
11131 whether there is a running but stopped thread. */
11132 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
11133 return target
->beneath
->to_read_description (target
->beneath
);
11135 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11137 struct remote_g_packet_guess
*guess
;
11139 int bytes
= send_g_packet ();
11142 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11144 if (guess
->bytes
== bytes
)
11145 return guess
->tdesc
;
11147 /* We discard the g packet. A minor optimization would be to
11148 hold on to it, and fill the register cache once we have selected
11149 an architecture, but it's too tricky to do safely. */
11152 return target
->beneath
->to_read_description (target
->beneath
);
11155 /* Remote file transfer support. This is host-initiated I/O, not
11156 target-initiated; for target-initiated, see remote-fileio.c. */
11158 /* If *LEFT is at least the length of STRING, copy STRING to
11159 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11160 decrease *LEFT. Otherwise raise an error. */
11163 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
11165 int len
= strlen (string
);
11168 error (_("Packet too long for target."));
11170 memcpy (*buffer
, string
, len
);
11174 /* NUL-terminate the buffer as a convenience, if there is
11180 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11181 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11182 decrease *LEFT. Otherwise raise an error. */
11185 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11188 if (2 * len
> *left
)
11189 error (_("Packet too long for target."));
11191 bin2hex (bytes
, *buffer
, len
);
11192 *buffer
+= 2 * len
;
11195 /* NUL-terminate the buffer as a convenience, if there is
11201 /* If *LEFT is large enough, convert VALUE to hex and add it to
11202 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11203 decrease *LEFT. Otherwise raise an error. */
11206 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11208 int len
= hexnumlen (value
);
11211 error (_("Packet too long for target."));
11213 hexnumstr (*buffer
, value
);
11217 /* NUL-terminate the buffer as a convenience, if there is
11223 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11224 value, *REMOTE_ERRNO to the remote error number or zero if none
11225 was included, and *ATTACHMENT to point to the start of the annex
11226 if any. The length of the packet isn't needed here; there may
11227 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11229 Return 0 if the packet could be parsed, -1 if it could not. If
11230 -1 is returned, the other variables may not be initialized. */
11233 remote_hostio_parse_result (char *buffer
, int *retcode
,
11234 int *remote_errno
, char **attachment
)
11239 *attachment
= NULL
;
11241 if (buffer
[0] != 'F')
11245 *retcode
= strtol (&buffer
[1], &p
, 16);
11246 if (errno
!= 0 || p
== &buffer
[1])
11249 /* Check for ",errno". */
11253 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11254 if (errno
!= 0 || p
+ 1 == p2
)
11259 /* Check for ";attachment". If there is no attachment, the
11260 packet should end here. */
11263 *attachment
= p
+ 1;
11266 else if (*p
== '\0')
11272 /* Send a prepared I/O packet to the target and read its response.
11273 The prepared packet is in the global RS->BUF before this function
11274 is called, and the answer is there when we return.
11276 COMMAND_BYTES is the length of the request to send, which may include
11277 binary data. WHICH_PACKET is the packet configuration to check
11278 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11279 is set to the error number and -1 is returned. Otherwise the value
11280 returned by the function is returned.
11282 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11283 attachment is expected; an error will be reported if there's a
11284 mismatch. If one is found, *ATTACHMENT will be set to point into
11285 the packet buffer and *ATTACHMENT_LEN will be set to the
11286 attachment's length. */
11289 remote_hostio_send_command (int command_bytes
, int which_packet
,
11290 int *remote_errno
, char **attachment
,
11291 int *attachment_len
)
11293 struct remote_state
*rs
= get_remote_state ();
11294 int ret
, bytes_read
;
11295 char *attachment_tmp
;
11297 if (!rs
->remote_desc
11298 || packet_support (which_packet
) == PACKET_DISABLE
)
11300 *remote_errno
= FILEIO_ENOSYS
;
11304 putpkt_binary (rs
->buf
, command_bytes
);
11305 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
11307 /* If it timed out, something is wrong. Don't try to parse the
11309 if (bytes_read
< 0)
11311 *remote_errno
= FILEIO_EINVAL
;
11315 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11318 *remote_errno
= FILEIO_EINVAL
;
11320 case PACKET_UNKNOWN
:
11321 *remote_errno
= FILEIO_ENOSYS
;
11327 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
11330 *remote_errno
= FILEIO_EINVAL
;
11334 /* Make sure we saw an attachment if and only if we expected one. */
11335 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11336 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11338 *remote_errno
= FILEIO_EINVAL
;
11342 /* If an attachment was found, it must point into the packet buffer;
11343 work out how many bytes there were. */
11344 if (attachment_tmp
!= NULL
)
11346 *attachment
= attachment_tmp
;
11347 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
11353 /* Invalidate the readahead cache. */
11356 readahead_cache_invalidate (void)
11358 struct remote_state
*rs
= get_remote_state ();
11360 rs
->readahead_cache
.fd
= -1;
11363 /* Invalidate the readahead cache if it is holding data for FD. */
11366 readahead_cache_invalidate_fd (int fd
)
11368 struct remote_state
*rs
= get_remote_state ();
11370 if (rs
->readahead_cache
.fd
== fd
)
11371 rs
->readahead_cache
.fd
= -1;
11374 /* Set the filesystem remote_hostio functions that take FILENAME
11375 arguments will use. Return 0 on success, or -1 if an error
11376 occurs (and set *REMOTE_ERRNO). */
11379 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
11381 struct remote_state
*rs
= get_remote_state ();
11382 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11384 int left
= get_remote_packet_size () - 1;
11388 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11391 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11394 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11396 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11397 remote_buffer_add_string (&p
, &left
, arg
);
11399 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
11400 remote_errno
, NULL
, NULL
);
11402 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11406 rs
->fs_pid
= required_pid
;
11411 /* Implementation of to_fileio_open. */
11414 remote_hostio_open (struct target_ops
*self
,
11415 struct inferior
*inf
, const char *filename
,
11416 int flags
, int mode
, int warn_if_slow
,
11419 struct remote_state
*rs
= get_remote_state ();
11421 int left
= get_remote_packet_size () - 1;
11425 static int warning_issued
= 0;
11427 printf_unfiltered (_("Reading %s from remote target...\n"),
11430 if (!warning_issued
)
11432 warning (_("File transfers from remote targets can be slow."
11433 " Use \"set sysroot\" to access files locally"
11435 warning_issued
= 1;
11439 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11442 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11444 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11445 strlen (filename
));
11446 remote_buffer_add_string (&p
, &left
, ",");
11448 remote_buffer_add_int (&p
, &left
, flags
);
11449 remote_buffer_add_string (&p
, &left
, ",");
11451 remote_buffer_add_int (&p
, &left
, mode
);
11453 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
11454 remote_errno
, NULL
, NULL
);
11457 /* Implementation of to_fileio_pwrite. */
11460 remote_hostio_pwrite (struct target_ops
*self
,
11461 int fd
, const gdb_byte
*write_buf
, int len
,
11462 ULONGEST offset
, int *remote_errno
)
11464 struct remote_state
*rs
= get_remote_state ();
11466 int left
= get_remote_packet_size ();
11469 readahead_cache_invalidate_fd (fd
);
11471 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11473 remote_buffer_add_int (&p
, &left
, fd
);
11474 remote_buffer_add_string (&p
, &left
, ",");
11476 remote_buffer_add_int (&p
, &left
, offset
);
11477 remote_buffer_add_string (&p
, &left
, ",");
11479 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11480 get_remote_packet_size () - (p
- rs
->buf
));
11482 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
11483 remote_errno
, NULL
, NULL
);
11486 /* Helper for the implementation of to_fileio_pread. Read the file
11487 from the remote side with vFile:pread. */
11490 remote_hostio_pread_vFile (struct target_ops
*self
,
11491 int fd
, gdb_byte
*read_buf
, int len
,
11492 ULONGEST offset
, int *remote_errno
)
11494 struct remote_state
*rs
= get_remote_state ();
11497 int left
= get_remote_packet_size ();
11498 int ret
, attachment_len
;
11501 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11503 remote_buffer_add_int (&p
, &left
, fd
);
11504 remote_buffer_add_string (&p
, &left
, ",");
11506 remote_buffer_add_int (&p
, &left
, len
);
11507 remote_buffer_add_string (&p
, &left
, ",");
11509 remote_buffer_add_int (&p
, &left
, offset
);
11511 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
11512 remote_errno
, &attachment
,
11518 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11520 if (read_len
!= ret
)
11521 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11526 /* Serve pread from the readahead cache. Returns number of bytes
11527 read, or 0 if the request can't be served from the cache. */
11530 remote_hostio_pread_from_cache (struct remote_state
*rs
,
11531 int fd
, gdb_byte
*read_buf
, size_t len
,
11534 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11536 if (cache
->fd
== fd
11537 && cache
->offset
<= offset
11538 && offset
< cache
->offset
+ cache
->bufsize
)
11540 ULONGEST max
= cache
->offset
+ cache
->bufsize
;
11542 if (offset
+ len
> max
)
11543 len
= max
- offset
;
11545 memcpy (read_buf
, cache
->buf
+ offset
- cache
->offset
, len
);
11552 /* Implementation of to_fileio_pread. */
11555 remote_hostio_pread (struct target_ops
*self
,
11556 int fd
, gdb_byte
*read_buf
, int len
,
11557 ULONGEST offset
, int *remote_errno
)
11560 struct remote_state
*rs
= get_remote_state ();
11561 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11563 ret
= remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11566 cache
->hit_count
++;
11569 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
11570 pulongest (cache
->hit_count
));
11574 cache
->miss_count
++;
11576 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
11577 pulongest (cache
->miss_count
));
11580 cache
->offset
= offset
;
11581 cache
->bufsize
= get_remote_packet_size ();
11582 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
11584 ret
= remote_hostio_pread_vFile (self
, cache
->fd
, cache
->buf
, cache
->bufsize
,
11585 cache
->offset
, remote_errno
);
11588 readahead_cache_invalidate_fd (fd
);
11592 cache
->bufsize
= ret
;
11593 return remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11596 /* Implementation of to_fileio_close. */
11599 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
11601 struct remote_state
*rs
= get_remote_state ();
11603 int left
= get_remote_packet_size () - 1;
11605 readahead_cache_invalidate_fd (fd
);
11607 remote_buffer_add_string (&p
, &left
, "vFile:close:");
11609 remote_buffer_add_int (&p
, &left
, fd
);
11611 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
11612 remote_errno
, NULL
, NULL
);
11615 /* Implementation of to_fileio_unlink. */
11618 remote_hostio_unlink (struct target_ops
*self
,
11619 struct inferior
*inf
, const char *filename
,
11622 struct remote_state
*rs
= get_remote_state ();
11624 int left
= get_remote_packet_size () - 1;
11626 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11629 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
11631 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11632 strlen (filename
));
11634 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
11635 remote_errno
, NULL
, NULL
);
11638 /* Implementation of to_fileio_readlink. */
11641 remote_hostio_readlink (struct target_ops
*self
,
11642 struct inferior
*inf
, const char *filename
,
11645 struct remote_state
*rs
= get_remote_state ();
11648 int left
= get_remote_packet_size ();
11649 int len
, attachment_len
;
11653 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11656 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
11658 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11659 strlen (filename
));
11661 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
11662 remote_errno
, &attachment
,
11668 ret
= (char *) xmalloc (len
+ 1);
11670 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11671 (gdb_byte
*) ret
, len
);
11672 if (read_len
!= len
)
11673 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
11679 /* Implementation of to_fileio_fstat. */
11682 remote_hostio_fstat (struct target_ops
*self
,
11683 int fd
, struct stat
*st
,
11686 struct remote_state
*rs
= get_remote_state ();
11688 int left
= get_remote_packet_size ();
11689 int attachment_len
, ret
;
11691 struct fio_stat fst
;
11694 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
11696 remote_buffer_add_int (&p
, &left
, fd
);
11698 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
11699 remote_errno
, &attachment
,
11703 if (*remote_errno
!= FILEIO_ENOSYS
)
11706 /* Strictly we should return -1, ENOSYS here, but when
11707 "set sysroot remote:" was implemented in August 2008
11708 BFD's need for a stat function was sidestepped with
11709 this hack. This was not remedied until March 2015
11710 so we retain the previous behavior to avoid breaking
11713 Note that the memset is a March 2015 addition; older
11714 GDBs set st_size *and nothing else* so the structure
11715 would have garbage in all other fields. This might
11716 break something but retaining the previous behavior
11717 here would be just too wrong. */
11719 memset (st
, 0, sizeof (struct stat
));
11720 st
->st_size
= INT_MAX
;
11724 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11725 (gdb_byte
*) &fst
, sizeof (fst
));
11727 if (read_len
!= ret
)
11728 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
11730 if (read_len
!= sizeof (fst
))
11731 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11732 read_len
, (int) sizeof (fst
));
11734 remote_fileio_to_host_stat (&fst
, st
);
11739 /* Implementation of to_filesystem_is_local. */
11742 remote_filesystem_is_local (struct target_ops
*self
)
11744 /* Valgrind GDB presents itself as a remote target but works
11745 on the local filesystem: it does not implement remote get
11746 and users are not expected to set a sysroot. To handle
11747 this case we treat the remote filesystem as local if the
11748 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11749 does not support vFile:open. */
11750 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
11752 enum packet_support ps
= packet_support (PACKET_vFile_open
);
11754 if (ps
== PACKET_SUPPORT_UNKNOWN
)
11756 int fd
, remote_errno
;
11758 /* Try opening a file to probe support. The supplied
11759 filename is irrelevant, we only care about whether
11760 the stub recognizes the packet or not. */
11761 fd
= remote_hostio_open (self
, NULL
, "just probing",
11762 FILEIO_O_RDONLY
, 0700, 0,
11766 remote_hostio_close (self
, fd
, &remote_errno
);
11768 ps
= packet_support (PACKET_vFile_open
);
11771 if (ps
== PACKET_DISABLE
)
11773 static int warning_issued
= 0;
11775 if (!warning_issued
)
11777 warning (_("remote target does not support file"
11778 " transfer, attempting to access files"
11779 " from local filesystem."));
11780 warning_issued
= 1;
11791 remote_fileio_errno_to_host (int errnum
)
11797 case FILEIO_ENOENT
:
11805 case FILEIO_EACCES
:
11807 case FILEIO_EFAULT
:
11811 case FILEIO_EEXIST
:
11813 case FILEIO_ENODEV
:
11815 case FILEIO_ENOTDIR
:
11817 case FILEIO_EISDIR
:
11819 case FILEIO_EINVAL
:
11821 case FILEIO_ENFILE
:
11823 case FILEIO_EMFILE
:
11827 case FILEIO_ENOSPC
:
11829 case FILEIO_ESPIPE
:
11833 case FILEIO_ENOSYS
:
11835 case FILEIO_ENAMETOOLONG
:
11836 return ENAMETOOLONG
;
11842 remote_hostio_error (int errnum
)
11844 int host_error
= remote_fileio_errno_to_host (errnum
);
11846 if (host_error
== -1)
11847 error (_("Unknown remote I/O error %d"), errnum
);
11849 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
11853 remote_hostio_close_cleanup (void *opaque
)
11855 int fd
= *(int *) opaque
;
11858 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
11862 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
11864 struct cleanup
*back_to
, *close_cleanup
;
11865 int retcode
, fd
, remote_errno
, bytes
, io_size
;
11868 int bytes_in_buffer
;
11871 struct remote_state
*rs
= get_remote_state ();
11873 if (!rs
->remote_desc
)
11874 error (_("command can only be used with remote target"));
11876 file
= gdb_fopen_cloexec (local_file
, "rb");
11878 perror_with_name (local_file
);
11879 back_to
= make_cleanup_fclose (file
);
11881 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11882 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
11884 0700, 0, &remote_errno
);
11886 remote_hostio_error (remote_errno
);
11888 /* Send up to this many bytes at once. They won't all fit in the
11889 remote packet limit, so we'll transfer slightly fewer. */
11890 io_size
= get_remote_packet_size ();
11891 buffer
= (gdb_byte
*) xmalloc (io_size
);
11892 make_cleanup (xfree
, buffer
);
11894 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11896 bytes_in_buffer
= 0;
11899 while (bytes_in_buffer
|| !saw_eof
)
11903 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
11904 io_size
- bytes_in_buffer
,
11909 error (_("Error reading %s."), local_file
);
11912 /* EOF. Unless there is something still in the
11913 buffer from the last iteration, we are done. */
11915 if (bytes_in_buffer
== 0)
11923 bytes
+= bytes_in_buffer
;
11924 bytes_in_buffer
= 0;
11926 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
11928 offset
, &remote_errno
);
11931 remote_hostio_error (remote_errno
);
11932 else if (retcode
== 0)
11933 error (_("Remote write of %d bytes returned 0!"), bytes
);
11934 else if (retcode
< bytes
)
11936 /* Short write. Save the rest of the read data for the next
11938 bytes_in_buffer
= bytes
- retcode
;
11939 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
11945 discard_cleanups (close_cleanup
);
11946 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
11947 remote_hostio_error (remote_errno
);
11950 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
11951 do_cleanups (back_to
);
11955 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
11957 struct cleanup
*back_to
, *close_cleanup
;
11958 int fd
, remote_errno
, bytes
, io_size
;
11962 struct remote_state
*rs
= get_remote_state ();
11964 if (!rs
->remote_desc
)
11965 error (_("command can only be used with remote target"));
11967 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11968 remote_file
, FILEIO_O_RDONLY
, 0, 0,
11971 remote_hostio_error (remote_errno
);
11973 file
= gdb_fopen_cloexec (local_file
, "wb");
11975 perror_with_name (local_file
);
11976 back_to
= make_cleanup_fclose (file
);
11978 /* Send up to this many bytes at once. They won't all fit in the
11979 remote packet limit, so we'll transfer slightly fewer. */
11980 io_size
= get_remote_packet_size ();
11981 buffer
= (gdb_byte
*) xmalloc (io_size
);
11982 make_cleanup (xfree
, buffer
);
11984 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11989 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
11990 fd
, buffer
, io_size
, offset
, &remote_errno
);
11992 /* Success, but no bytes, means end-of-file. */
11995 remote_hostio_error (remote_errno
);
11999 bytes
= fwrite (buffer
, 1, bytes
, file
);
12001 perror_with_name (local_file
);
12004 discard_cleanups (close_cleanup
);
12005 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12006 remote_hostio_error (remote_errno
);
12009 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12010 do_cleanups (back_to
);
12014 remote_file_delete (const char *remote_file
, int from_tty
)
12016 int retcode
, remote_errno
;
12017 struct remote_state
*rs
= get_remote_state ();
12019 if (!rs
->remote_desc
)
12020 error (_("command can only be used with remote target"));
12022 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
12023 NULL
, remote_file
, &remote_errno
);
12025 remote_hostio_error (remote_errno
);
12028 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12032 remote_put_command (char *args
, int from_tty
)
12034 struct cleanup
*back_to
;
12038 error_no_arg (_("file to put"));
12040 argv
= gdb_buildargv (args
);
12041 back_to
= make_cleanup_freeargv (argv
);
12042 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12043 error (_("Invalid parameters to remote put"));
12045 remote_file_put (argv
[0], argv
[1], from_tty
);
12047 do_cleanups (back_to
);
12051 remote_get_command (char *args
, int from_tty
)
12053 struct cleanup
*back_to
;
12057 error_no_arg (_("file to get"));
12059 argv
= gdb_buildargv (args
);
12060 back_to
= make_cleanup_freeargv (argv
);
12061 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12062 error (_("Invalid parameters to remote get"));
12064 remote_file_get (argv
[0], argv
[1], from_tty
);
12066 do_cleanups (back_to
);
12070 remote_delete_command (char *args
, int from_tty
)
12072 struct cleanup
*back_to
;
12076 error_no_arg (_("file to delete"));
12078 argv
= gdb_buildargv (args
);
12079 back_to
= make_cleanup_freeargv (argv
);
12080 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12081 error (_("Invalid parameters to remote delete"));
12083 remote_file_delete (argv
[0], from_tty
);
12085 do_cleanups (back_to
);
12089 remote_command (char *args
, int from_tty
)
12091 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12095 remote_can_execute_reverse (struct target_ops
*self
)
12097 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12098 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12105 remote_supports_non_stop (struct target_ops
*self
)
12111 remote_supports_disable_randomization (struct target_ops
*self
)
12113 /* Only supported in extended mode. */
12118 remote_supports_multi_process (struct target_ops
*self
)
12120 struct remote_state
*rs
= get_remote_state ();
12122 return remote_multi_process_p (rs
);
12126 remote_supports_cond_tracepoints (void)
12128 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12132 remote_supports_cond_breakpoints (struct target_ops
*self
)
12134 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12138 remote_supports_fast_tracepoints (void)
12140 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12144 remote_supports_static_tracepoints (void)
12146 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12150 remote_supports_install_in_trace (void)
12152 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12156 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
12158 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12163 remote_supports_string_tracing (struct target_ops
*self
)
12165 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12169 remote_can_run_breakpoint_commands (struct target_ops
*self
)
12171 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12175 remote_trace_init (struct target_ops
*self
)
12178 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12179 if (strcmp (target_buf
, "OK") != 0)
12180 error (_("Target does not support this command."));
12183 static void free_actions_list (char **actions_list
);
12184 static void free_actions_list_cleanup_wrapper (void *);
12186 free_actions_list_cleanup_wrapper (void *al
)
12188 free_actions_list ((char **) al
);
12192 free_actions_list (char **actions_list
)
12196 if (actions_list
== 0)
12199 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
12200 xfree (actions_list
[ndx
]);
12202 xfree (actions_list
);
12205 /* Recursive routine to walk through command list including loops, and
12206 download packets for each command. */
12209 remote_download_command_source (int num
, ULONGEST addr
,
12210 struct command_line
*cmds
)
12212 struct remote_state
*rs
= get_remote_state ();
12213 struct command_line
*cmd
;
12215 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12217 QUIT
; /* Allow user to bail out with ^C. */
12218 strcpy (rs
->buf
, "QTDPsrc:");
12219 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12220 rs
->buf
+ strlen (rs
->buf
),
12221 rs
->buf_size
- strlen (rs
->buf
));
12223 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12224 if (strcmp (target_buf
, "OK"))
12225 warning (_("Target does not support source download."));
12227 if (cmd
->control_type
== while_control
12228 || cmd
->control_type
== while_stepping_control
)
12230 remote_download_command_source (num
, addr
, *cmd
->body_list
);
12232 QUIT
; /* Allow user to bail out with ^C. */
12233 strcpy (rs
->buf
, "QTDPsrc:");
12234 encode_source_string (num
, addr
, "cmd", "end",
12235 rs
->buf
+ strlen (rs
->buf
),
12236 rs
->buf_size
- strlen (rs
->buf
));
12238 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12239 if (strcmp (target_buf
, "OK"))
12240 warning (_("Target does not support source download."));
12246 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
12248 #define BUF_SIZE 2048
12252 char buf
[BUF_SIZE
];
12253 char **tdp_actions
;
12254 char **stepping_actions
;
12256 struct cleanup
*old_chain
= NULL
;
12258 struct breakpoint
*b
= loc
->owner
;
12259 struct tracepoint
*t
= (struct tracepoint
*) b
;
12261 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12262 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
12264 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
12267 tpaddr
= loc
->address
;
12268 sprintf_vma (addrbuf
, tpaddr
);
12269 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
12270 addrbuf
, /* address */
12271 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12272 t
->step_count
, t
->pass_count
);
12273 /* Fast tracepoints are mostly handled by the target, but we can
12274 tell the target how big of an instruction block should be moved
12276 if (b
->type
== bp_fast_tracepoint
)
12278 /* Only test for support at download time; we may not know
12279 target capabilities at definition time. */
12280 if (remote_supports_fast_tracepoints ())
12282 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12284 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
12285 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12287 /* If it passed validation at definition but fails now,
12288 something is very wrong. */
12289 internal_error (__FILE__
, __LINE__
,
12290 _("Fast tracepoint not "
12291 "valid during download"));
12294 /* Fast tracepoints are functionally identical to regular
12295 tracepoints, so don't take lack of support as a reason to
12296 give up on the trace run. */
12297 warning (_("Target does not support fast tracepoints, "
12298 "downloading %d as regular tracepoint"), b
->number
);
12300 else if (b
->type
== bp_static_tracepoint
)
12302 /* Only test for support at download time; we may not know
12303 target capabilities at definition time. */
12304 if (remote_supports_static_tracepoints ())
12306 struct static_tracepoint_marker marker
;
12308 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12309 strcat (buf
, ":S");
12311 error (_("Static tracepoint not valid during download"));
12314 /* Fast tracepoints are functionally identical to regular
12315 tracepoints, so don't take lack of support as a reason
12316 to give up on the trace run. */
12317 error (_("Target does not support static tracepoints"));
12319 /* If the tracepoint has a conditional, make it into an agent
12320 expression and append to the definition. */
12323 /* Only test support at download time, we may not know target
12324 capabilities at definition time. */
12325 if (remote_supports_cond_tracepoints ())
12327 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
.get ());
12328 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
12330 pkt
= buf
+ strlen (buf
);
12331 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12332 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12336 warning (_("Target does not support conditional tracepoints, "
12337 "ignoring tp %d cond"), b
->number
);
12340 if (b
->commands
|| *default_collect
)
12343 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12344 if (strcmp (target_buf
, "OK"))
12345 error (_("Target does not support tracepoints."));
12347 /* do_single_steps (t); */
12350 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
12352 QUIT
; /* Allow user to bail out with ^C. */
12353 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
12354 b
->number
, addrbuf
, /* address */
12356 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
12359 remote_get_noisy_reply (&target_buf
,
12361 if (strcmp (target_buf
, "OK"))
12362 error (_("Error on target while setting tracepoints."));
12365 if (stepping_actions
)
12367 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
12369 QUIT
; /* Allow user to bail out with ^C. */
12370 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
12371 b
->number
, addrbuf
, /* address */
12372 ((ndx
== 0) ? "S" : ""),
12373 stepping_actions
[ndx
],
12374 (stepping_actions
[ndx
+ 1] ? "-" : ""));
12376 remote_get_noisy_reply (&target_buf
,
12378 if (strcmp (target_buf
, "OK"))
12379 error (_("Error on target while setting tracepoints."));
12383 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12385 if (b
->location
!= NULL
)
12387 strcpy (buf
, "QTDPsrc:");
12388 encode_source_string (b
->number
, loc
->address
, "at",
12389 event_location_to_string (b
->location
),
12390 buf
+ strlen (buf
), 2048 - strlen (buf
));
12392 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12393 if (strcmp (target_buf
, "OK"))
12394 warning (_("Target does not support source download."));
12396 if (b
->cond_string
)
12398 strcpy (buf
, "QTDPsrc:");
12399 encode_source_string (b
->number
, loc
->address
,
12400 "cond", b
->cond_string
, buf
+ strlen (buf
),
12401 2048 - strlen (buf
));
12403 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12404 if (strcmp (target_buf
, "OK"))
12405 warning (_("Target does not support source download."));
12407 remote_download_command_source (b
->number
, loc
->address
,
12408 breakpoint_commands (b
));
12411 do_cleanups (old_chain
);
12415 remote_can_download_tracepoint (struct target_ops
*self
)
12417 struct remote_state
*rs
= get_remote_state ();
12418 struct trace_status
*ts
;
12421 /* Don't try to install tracepoints until we've relocated our
12422 symbols, and fetched and merged the target's tracepoint list with
12424 if (rs
->starting_up
)
12427 ts
= current_trace_status ();
12428 status
= remote_get_trace_status (self
, ts
);
12430 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12433 /* If we are in a tracing experiment, but remote stub doesn't support
12434 installing tracepoint in trace, we have to return. */
12435 if (!remote_supports_install_in_trace ())
12443 remote_download_trace_state_variable (struct target_ops
*self
,
12444 struct trace_state_variable
*tsv
)
12446 struct remote_state
*rs
= get_remote_state ();
12449 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12450 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
12452 p
= rs
->buf
+ strlen (rs
->buf
);
12453 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
12454 error (_("Trace state variable name too long for tsv definition packet"));
12455 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
12458 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12459 if (*target_buf
== '\0')
12460 error (_("Target does not support this command."));
12461 if (strcmp (target_buf
, "OK") != 0)
12462 error (_("Error on target while downloading trace state variable."));
12466 remote_enable_tracepoint (struct target_ops
*self
,
12467 struct bp_location
*location
)
12469 struct remote_state
*rs
= get_remote_state ();
12472 sprintf_vma (addr_buf
, location
->address
);
12473 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
12474 location
->owner
->number
, addr_buf
);
12476 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12477 if (*rs
->buf
== '\0')
12478 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12479 if (strcmp (rs
->buf
, "OK") != 0)
12480 error (_("Error on target while enabling tracepoint."));
12484 remote_disable_tracepoint (struct target_ops
*self
,
12485 struct bp_location
*location
)
12487 struct remote_state
*rs
= get_remote_state ();
12490 sprintf_vma (addr_buf
, location
->address
);
12491 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
12492 location
->owner
->number
, addr_buf
);
12494 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12495 if (*rs
->buf
== '\0')
12496 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12497 if (strcmp (rs
->buf
, "OK") != 0)
12498 error (_("Error on target while disabling tracepoint."));
12502 remote_trace_set_readonly_regions (struct target_ops
*self
)
12506 bfd_size_type size
;
12512 return; /* No information to give. */
12514 strcpy (target_buf
, "QTro");
12515 offset
= strlen (target_buf
);
12516 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
12518 char tmp1
[40], tmp2
[40];
12521 if ((s
->flags
& SEC_LOAD
) == 0 ||
12522 /* (s->flags & SEC_CODE) == 0 || */
12523 (s
->flags
& SEC_READONLY
) == 0)
12527 vma
= bfd_get_section_vma (abfd
, s
);
12528 size
= bfd_get_section_size (s
);
12529 sprintf_vma (tmp1
, vma
);
12530 sprintf_vma (tmp2
, vma
+ size
);
12531 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
12532 if (offset
+ sec_length
+ 1 > target_buf_size
)
12534 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
12536 Too many sections for read-only sections definition packet."));
12539 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
12541 offset
+= sec_length
;
12545 putpkt (target_buf
);
12546 getpkt (&target_buf
, &target_buf_size
, 0);
12551 remote_trace_start (struct target_ops
*self
)
12553 putpkt ("QTStart");
12554 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12555 if (*target_buf
== '\0')
12556 error (_("Target does not support this command."));
12557 if (strcmp (target_buf
, "OK") != 0)
12558 error (_("Bogus reply from target: %s"), target_buf
);
12562 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
12564 /* Initialize it just to avoid a GCC false warning. */
12566 /* FIXME we need to get register block size some other way. */
12567 extern int trace_regblock_size
;
12568 enum packet_result result
;
12570 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
12573 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
12575 putpkt ("qTStatus");
12579 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12581 CATCH (ex
, RETURN_MASK_ERROR
)
12583 if (ex
.error
!= TARGET_CLOSE_ERROR
)
12585 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
12588 throw_exception (ex
);
12592 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
12594 /* If the remote target doesn't do tracing, flag it. */
12595 if (result
== PACKET_UNKNOWN
)
12598 /* We're working with a live target. */
12599 ts
->filename
= NULL
;
12602 error (_("Bogus trace status reply from target: %s"), target_buf
);
12604 /* Function 'parse_trace_status' sets default value of each field of
12605 'ts' at first, so we don't have to do it here. */
12606 parse_trace_status (p
, ts
);
12608 return ts
->running
;
12612 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
12613 struct uploaded_tp
*utp
)
12615 struct remote_state
*rs
= get_remote_state ();
12617 struct bp_location
*loc
;
12618 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
12619 size_t size
= get_remote_packet_size ();
12623 tp
->base
.hit_count
= 0;
12624 tp
->traceframe_usage
= 0;
12625 for (loc
= tp
->base
.loc
; loc
; loc
= loc
->next
)
12627 /* If the tracepoint was never downloaded, don't go asking for
12629 if (tp
->number_on_target
== 0)
12631 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
12632 phex_nz (loc
->address
, 0));
12634 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12635 if (reply
&& *reply
)
12638 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12644 utp
->hit_count
= 0;
12645 utp
->traceframe_usage
= 0;
12646 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
12647 phex_nz (utp
->addr
, 0));
12649 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12650 if (reply
&& *reply
)
12653 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12659 remote_trace_stop (struct target_ops
*self
)
12662 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12663 if (*target_buf
== '\0')
12664 error (_("Target does not support this command."));
12665 if (strcmp (target_buf
, "OK") != 0)
12666 error (_("Bogus reply from target: %s"), target_buf
);
12670 remote_trace_find (struct target_ops
*self
,
12671 enum trace_find_type type
, int num
,
12672 CORE_ADDR addr1
, CORE_ADDR addr2
,
12675 struct remote_state
*rs
= get_remote_state ();
12676 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12678 int target_frameno
= -1, target_tracept
= -1;
12680 /* Lookups other than by absolute frame number depend on the current
12681 trace selected, so make sure it is correct on the remote end
12683 if (type
!= tfind_number
)
12684 set_remote_traceframe ();
12687 strcpy (p
, "QTFrame:");
12688 p
= strchr (p
, '\0');
12692 xsnprintf (p
, endbuf
- p
, "%x", num
);
12695 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
12698 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
12701 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
12702 phex_nz (addr2
, 0));
12704 case tfind_outside
:
12705 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
12706 phex_nz (addr2
, 0));
12709 error (_("Unknown trace find type %d"), type
);
12713 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
12714 if (*reply
== '\0')
12715 error (_("Target does not support this command."));
12717 while (reply
&& *reply
)
12722 target_frameno
= (int) strtol (p
, &reply
, 16);
12724 error (_("Unable to parse trace frame number"));
12725 /* Don't update our remote traceframe number cache on failure
12726 to select a remote traceframe. */
12727 if (target_frameno
== -1)
12732 target_tracept
= (int) strtol (p
, &reply
, 16);
12734 error (_("Unable to parse tracepoint number"));
12736 case 'O': /* "OK"? */
12737 if (reply
[1] == 'K' && reply
[2] == '\0')
12740 error (_("Bogus reply from target: %s"), reply
);
12743 error (_("Bogus reply from target: %s"), reply
);
12746 *tpp
= target_tracept
;
12748 rs
->remote_traceframe_number
= target_frameno
;
12749 return target_frameno
;
12753 remote_get_trace_state_variable_value (struct target_ops
*self
,
12754 int tsvnum
, LONGEST
*val
)
12756 struct remote_state
*rs
= get_remote_state ();
12760 set_remote_traceframe ();
12762 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
12764 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12765 if (reply
&& *reply
)
12769 unpack_varlen_hex (reply
+ 1, &uval
);
12770 *val
= (LONGEST
) uval
;
12778 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
12780 struct remote_state
*rs
= get_remote_state ();
12784 strcpy (p
, "QTSave:");
12786 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
12787 error (_("Remote file name too long for trace save packet"));
12788 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
12791 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12792 if (*reply
== '\0')
12793 error (_("Target does not support this command."));
12794 if (strcmp (reply
, "OK") != 0)
12795 error (_("Bogus reply from target: %s"), reply
);
12799 /* This is basically a memory transfer, but needs to be its own packet
12800 because we don't know how the target actually organizes its trace
12801 memory, plus we want to be able to ask for as much as possible, but
12802 not be unhappy if we don't get as much as we ask for. */
12805 remote_get_raw_trace_data (struct target_ops
*self
,
12806 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
12808 struct remote_state
*rs
= get_remote_state ();
12814 strcpy (p
, "qTBuffer:");
12816 p
+= hexnumstr (p
, offset
);
12818 p
+= hexnumstr (p
, len
);
12822 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12823 if (reply
&& *reply
)
12825 /* 'l' by itself means we're at the end of the buffer and
12826 there is nothing more to get. */
12830 /* Convert the reply into binary. Limit the number of bytes to
12831 convert according to our passed-in buffer size, rather than
12832 what was returned in the packet; if the target is
12833 unexpectedly generous and gives us a bigger reply than we
12834 asked for, we don't want to crash. */
12835 rslt
= hex2bin (target_buf
, buf
, len
);
12839 /* Something went wrong, flag as an error. */
12844 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
12846 struct remote_state
*rs
= get_remote_state ();
12848 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
12852 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
12854 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12855 if (*reply
== '\0')
12856 error (_("Target does not support this command."));
12857 if (strcmp (reply
, "OK") != 0)
12858 error (_("Bogus reply from target: %s"), reply
);
12861 warning (_("Target does not support disconnected tracing."));
12865 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
12867 struct thread_info
*info
= find_thread_ptid (ptid
);
12869 if (info
&& info
->priv
)
12870 return info
->priv
->core
;
12875 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
12877 struct remote_state
*rs
= get_remote_state ();
12880 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
12882 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12883 if (*reply
== '\0')
12884 error (_("Target does not support this command."));
12885 if (strcmp (reply
, "OK") != 0)
12886 error (_("Bogus reply from target: %s"), reply
);
12889 static struct traceframe_info
*
12890 remote_traceframe_info (struct target_ops
*self
)
12894 text
= target_read_stralloc (¤t_target
,
12895 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
12898 struct traceframe_info
*info
;
12899 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
12901 info
= parse_traceframe_info (text
);
12902 do_cleanups (back_to
);
12909 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12910 instruction on which a fast tracepoint may be placed. Returns -1
12911 if the packet is not supported, and 0 if the minimum instruction
12912 length is unknown. */
12915 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
12917 struct remote_state
*rs
= get_remote_state ();
12920 /* If we're not debugging a process yet, the IPA can't be
12922 if (!target_has_execution
)
12925 /* Make sure the remote is pointing at the right process. */
12926 set_general_process ();
12928 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
12930 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12931 if (*reply
== '\0')
12935 ULONGEST min_insn_len
;
12937 unpack_varlen_hex (reply
, &min_insn_len
);
12939 return (int) min_insn_len
;
12944 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
12946 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
12948 struct remote_state
*rs
= get_remote_state ();
12949 char *buf
= rs
->buf
;
12950 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12951 enum packet_result result
;
12953 gdb_assert (val
>= 0 || val
== -1);
12954 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
12955 /* Send -1 as literal "-1" to avoid host size dependency. */
12959 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
12962 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
12965 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12966 result
= packet_ok (rs
->buf
,
12967 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
12969 if (result
!= PACKET_OK
)
12970 warning (_("Bogus reply from target: %s"), rs
->buf
);
12975 remote_set_trace_notes (struct target_ops
*self
,
12976 const char *user
, const char *notes
,
12977 const char *stop_notes
)
12979 struct remote_state
*rs
= get_remote_state ();
12981 char *buf
= rs
->buf
;
12982 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12985 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
12988 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
12989 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
12995 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
12996 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13002 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13003 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13007 /* Ensure the buffer is terminated. */
13011 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
13012 if (*reply
== '\0')
13015 if (strcmp (reply
, "OK") != 0)
13016 error (_("Bogus reply from target: %s"), reply
);
13022 remote_use_agent (struct target_ops
*self
, int use
)
13024 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13026 struct remote_state
*rs
= get_remote_state ();
13028 /* If the stub supports QAgent. */
13029 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
13031 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13033 if (strcmp (rs
->buf
, "OK") == 0)
13044 remote_can_use_agent (struct target_ops
*self
)
13046 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13049 struct btrace_target_info
13051 /* The ptid of the traced thread. */
13054 /* The obtained branch trace configuration. */
13055 struct btrace_config conf
;
13058 /* Reset our idea of our target's btrace configuration. */
13061 remote_btrace_reset (void)
13063 struct remote_state
*rs
= get_remote_state ();
13065 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13068 /* Check whether the target supports branch tracing. */
13071 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
13073 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
13075 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
13080 case BTRACE_FORMAT_NONE
:
13083 case BTRACE_FORMAT_BTS
:
13084 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
13086 case BTRACE_FORMAT_PT
:
13087 /* The trace is decoded on the host. Even if our target supports it,
13088 we still need to have libipt to decode the trace. */
13089 #if defined (HAVE_LIBIPT)
13090 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
13091 #else /* !defined (HAVE_LIBIPT) */
13093 #endif /* !defined (HAVE_LIBIPT) */
13096 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
13099 /* Synchronize the configuration with the target. */
13102 btrace_sync_conf (const struct btrace_config
*conf
)
13104 struct packet_config
*packet
;
13105 struct remote_state
*rs
;
13106 char *buf
, *pos
, *endbuf
;
13108 rs
= get_remote_state ();
13110 endbuf
= buf
+ get_remote_packet_size ();
13112 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13113 if (packet_config_support (packet
) == PACKET_ENABLE
13114 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13117 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13121 getpkt (&buf
, &rs
->buf_size
, 0);
13123 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13125 if (buf
[0] == 'E' && buf
[1] == '.')
13126 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13128 error (_("Failed to configure the BTS buffer size."));
13131 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13134 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13135 if (packet_config_support (packet
) == PACKET_ENABLE
13136 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13139 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13143 getpkt (&buf
, &rs
->buf_size
, 0);
13145 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13147 if (buf
[0] == 'E' && buf
[1] == '.')
13148 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13150 error (_("Failed to configure the trace buffer size."));
13153 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13157 /* Read the current thread's btrace configuration from the target and
13158 store it into CONF. */
13161 btrace_read_config (struct btrace_config
*conf
)
13165 xml
= target_read_stralloc (¤t_target
,
13166 TARGET_OBJECT_BTRACE_CONF
, "");
13169 struct cleanup
*cleanup
;
13171 cleanup
= make_cleanup (xfree
, xml
);
13172 parse_xml_btrace_conf (conf
, xml
);
13173 do_cleanups (cleanup
);
13177 /* Maybe reopen target btrace. */
13180 remote_btrace_maybe_reopen (void)
13182 struct remote_state
*rs
= get_remote_state ();
13183 struct cleanup
*cleanup
;
13184 struct thread_info
*tp
;
13185 int btrace_target_pushed
= 0;
13188 cleanup
= make_cleanup_restore_current_thread ();
13189 ALL_NON_EXITED_THREADS (tp
)
13191 set_general_thread (tp
->ptid
);
13193 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13194 btrace_read_config (&rs
->btrace_config
);
13196 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13199 #if !defined (HAVE_LIBIPT)
13200 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13205 warning (_("GDB does not support Intel Processor Trace. "
13206 "\"record\" will not work in this session."));
13211 #endif /* !defined (HAVE_LIBIPT) */
13213 /* Push target, once, but before anything else happens. This way our
13214 changes to the threads will be cleaned up by unpushing the target
13215 in case btrace_read_config () throws. */
13216 if (!btrace_target_pushed
)
13218 btrace_target_pushed
= 1;
13219 record_btrace_push_target ();
13220 printf_filtered (_("Target is recording using %s.\n"),
13221 btrace_format_string (rs
->btrace_config
.format
));
13224 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13225 tp
->btrace
.target
->ptid
= tp
->ptid
;
13226 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13228 do_cleanups (cleanup
);
13231 /* Enable branch tracing. */
13233 static struct btrace_target_info
*
13234 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
13235 const struct btrace_config
*conf
)
13237 struct btrace_target_info
*tinfo
= NULL
;
13238 struct packet_config
*packet
= NULL
;
13239 struct remote_state
*rs
= get_remote_state ();
13240 char *buf
= rs
->buf
;
13241 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13243 switch (conf
->format
)
13245 case BTRACE_FORMAT_BTS
:
13246 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13249 case BTRACE_FORMAT_PT
:
13250 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13254 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13255 error (_("Target does not support branch tracing."));
13257 btrace_sync_conf (conf
);
13259 set_general_thread (ptid
);
13261 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13263 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13265 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13267 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13268 error (_("Could not enable branch tracing for %s: %s"),
13269 target_pid_to_str (ptid
), rs
->buf
+ 2);
13271 error (_("Could not enable branch tracing for %s."),
13272 target_pid_to_str (ptid
));
13275 tinfo
= XCNEW (struct btrace_target_info
);
13276 tinfo
->ptid
= ptid
;
13278 /* If we fail to read the configuration, we lose some information, but the
13279 tracing itself is not impacted. */
13282 btrace_read_config (&tinfo
->conf
);
13284 CATCH (err
, RETURN_MASK_ERROR
)
13286 if (err
.message
!= NULL
)
13287 warning ("%s", err
.message
);
13294 /* Disable branch tracing. */
13297 remote_disable_btrace (struct target_ops
*self
,
13298 struct btrace_target_info
*tinfo
)
13300 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13301 struct remote_state
*rs
= get_remote_state ();
13302 char *buf
= rs
->buf
;
13303 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13305 if (packet_config_support (packet
) != PACKET_ENABLE
)
13306 error (_("Target does not support branch tracing."));
13308 set_general_thread (tinfo
->ptid
);
13310 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13312 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13314 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13316 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13317 error (_("Could not disable branch tracing for %s: %s"),
13318 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
13320 error (_("Could not disable branch tracing for %s."),
13321 target_pid_to_str (tinfo
->ptid
));
13327 /* Teardown branch tracing. */
13330 remote_teardown_btrace (struct target_ops
*self
,
13331 struct btrace_target_info
*tinfo
)
13333 /* We must not talk to the target during teardown. */
13337 /* Read the branch trace. */
13339 static enum btrace_error
13340 remote_read_btrace (struct target_ops
*self
,
13341 struct btrace_data
*btrace
,
13342 struct btrace_target_info
*tinfo
,
13343 enum btrace_read_type type
)
13345 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13346 struct cleanup
*cleanup
;
13350 if (packet_config_support (packet
) != PACKET_ENABLE
)
13351 error (_("Target does not support branch tracing."));
13353 #if !defined(HAVE_LIBEXPAT)
13354 error (_("Cannot process branch tracing result. XML parsing not supported."));
13359 case BTRACE_READ_ALL
:
13362 case BTRACE_READ_NEW
:
13365 case BTRACE_READ_DELTA
:
13369 internal_error (__FILE__
, __LINE__
,
13370 _("Bad branch tracing read type: %u."),
13371 (unsigned int) type
);
13374 xml
= target_read_stralloc (¤t_target
,
13375 TARGET_OBJECT_BTRACE
, annex
);
13377 return BTRACE_ERR_UNKNOWN
;
13379 cleanup
= make_cleanup (xfree
, xml
);
13380 parse_xml_btrace (btrace
, xml
);
13381 do_cleanups (cleanup
);
13383 return BTRACE_ERR_NONE
;
13386 static const struct btrace_config
*
13387 remote_btrace_conf (struct target_ops
*self
,
13388 const struct btrace_target_info
*tinfo
)
13390 return &tinfo
->conf
;
13394 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
13396 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13400 /* Implementation of to_load. */
13403 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
13405 generic_load (name
, from_tty
);
13408 /* Accepts an integer PID; returns a string representing a file that
13409 can be opened on the remote side to get the symbols for the child
13410 process. Returns NULL if the operation is not supported. */
13413 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
13415 static char *filename
= NULL
;
13416 struct inferior
*inf
;
13417 char *annex
= NULL
;
13419 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13422 if (filename
!= NULL
)
13425 inf
= find_inferior_pid (pid
);
13427 internal_error (__FILE__
, __LINE__
,
13428 _("not currently attached to process %d"), pid
);
13430 if (!inf
->fake_pid_p
)
13432 const int annex_size
= 9;
13434 annex
= (char *) alloca (annex_size
);
13435 xsnprintf (annex
, annex_size
, "%x", pid
);
13438 filename
= target_read_stralloc (¤t_target
,
13439 TARGET_OBJECT_EXEC_FILE
, annex
);
13444 /* Implement the to_can_do_single_step target_ops method. */
13447 remote_can_do_single_step (struct target_ops
*ops
)
13449 /* We can only tell whether target supports single step or not by
13450 supported s and S vCont actions if the stub supports vContSupported
13451 feature. If the stub doesn't support vContSupported feature,
13452 we have conservatively to think target doesn't supports single
13454 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13456 struct remote_state
*rs
= get_remote_state ();
13458 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13459 remote_vcont_probe (rs
);
13461 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13467 /* Implementation of the to_execution_direction method for the remote
13470 static enum exec_direction_kind
13471 remote_execution_direction (struct target_ops
*self
)
13473 struct remote_state
*rs
= get_remote_state ();
13475 return rs
->last_resume_exec_dir
;
13479 init_remote_ops (void)
13481 remote_ops
.to_shortname
= "remote";
13482 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
13483 remote_ops
.to_doc
=
13484 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13485 Specify the serial device it is connected to\n\
13486 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13487 remote_ops
.to_open
= remote_open
;
13488 remote_ops
.to_close
= remote_close
;
13489 remote_ops
.to_detach
= remote_detach
;
13490 remote_ops
.to_disconnect
= remote_disconnect
;
13491 remote_ops
.to_resume
= remote_resume
;
13492 remote_ops
.to_commit_resume
= remote_commit_resume
;
13493 remote_ops
.to_wait
= remote_wait
;
13494 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
13495 remote_ops
.to_store_registers
= remote_store_registers
;
13496 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
13497 remote_ops
.to_files_info
= remote_files_info
;
13498 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
13499 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
13500 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
13501 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
13502 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
13503 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
13504 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
13505 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
13506 remote_ops
.to_watchpoint_addr_within_range
=
13507 remote_watchpoint_addr_within_range
;
13508 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
13509 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
13510 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
13511 remote_ops
.to_region_ok_for_hw_watchpoint
13512 = remote_region_ok_for_hw_watchpoint
;
13513 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
13514 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
13515 remote_ops
.to_kill
= remote_kill
;
13516 remote_ops
.to_load
= remote_load
;
13517 remote_ops
.to_mourn_inferior
= remote_mourn
;
13518 remote_ops
.to_pass_signals
= remote_pass_signals
;
13519 remote_ops
.to_set_syscall_catchpoint
= remote_set_syscall_catchpoint
;
13520 remote_ops
.to_program_signals
= remote_program_signals
;
13521 remote_ops
.to_thread_alive
= remote_thread_alive
;
13522 remote_ops
.to_thread_name
= remote_thread_name
;
13523 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
13524 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
13525 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
13526 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
13527 remote_ops
.to_stop
= remote_stop
;
13528 remote_ops
.to_interrupt
= remote_interrupt
;
13529 remote_ops
.to_pass_ctrlc
= remote_pass_ctrlc
;
13530 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
13531 remote_ops
.to_get_memory_xfer_limit
= remote_get_memory_xfer_limit
;
13532 remote_ops
.to_rcmd
= remote_rcmd
;
13533 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
13534 remote_ops
.to_log_command
= serial_log_command
;
13535 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
13536 remote_ops
.to_stratum
= process_stratum
;
13537 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
13538 remote_ops
.to_has_memory
= default_child_has_memory
;
13539 remote_ops
.to_has_stack
= default_child_has_stack
;
13540 remote_ops
.to_has_registers
= default_child_has_registers
;
13541 remote_ops
.to_has_execution
= default_child_has_execution
;
13542 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
13543 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
13544 remote_ops
.to_magic
= OPS_MAGIC
;
13545 remote_ops
.to_memory_map
= remote_memory_map
;
13546 remote_ops
.to_flash_erase
= remote_flash_erase
;
13547 remote_ops
.to_flash_done
= remote_flash_done
;
13548 remote_ops
.to_read_description
= remote_read_description
;
13549 remote_ops
.to_search_memory
= remote_search_memory
;
13550 remote_ops
.to_can_async_p
= remote_can_async_p
;
13551 remote_ops
.to_is_async_p
= remote_is_async_p
;
13552 remote_ops
.to_async
= remote_async
;
13553 remote_ops
.to_thread_events
= remote_thread_events
;
13554 remote_ops
.to_can_do_single_step
= remote_can_do_single_step
;
13555 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
13556 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
13557 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
13558 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
13559 remote_ops
.to_supports_disable_randomization
13560 = remote_supports_disable_randomization
;
13561 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
13562 remote_ops
.to_fileio_open
= remote_hostio_open
;
13563 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
13564 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
13565 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
13566 remote_ops
.to_fileio_close
= remote_hostio_close
;
13567 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
13568 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
13569 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
13570 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
13571 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
13572 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
13573 remote_ops
.to_trace_init
= remote_trace_init
;
13574 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
13575 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
13576 remote_ops
.to_download_trace_state_variable
13577 = remote_download_trace_state_variable
;
13578 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
13579 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
13580 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
13581 remote_ops
.to_trace_start
= remote_trace_start
;
13582 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
13583 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
13584 remote_ops
.to_trace_stop
= remote_trace_stop
;
13585 remote_ops
.to_trace_find
= remote_trace_find
;
13586 remote_ops
.to_get_trace_state_variable_value
13587 = remote_get_trace_state_variable_value
;
13588 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
13589 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
13590 remote_ops
.to_upload_trace_state_variables
13591 = remote_upload_trace_state_variables
;
13592 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
13593 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
13594 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
13595 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
13596 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
13597 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
13598 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
13599 remote_ops
.to_verify_memory
= remote_verify_memory
;
13600 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
13601 remote_ops
.to_set_permissions
= remote_set_permissions
;
13602 remote_ops
.to_static_tracepoint_marker_at
13603 = remote_static_tracepoint_marker_at
;
13604 remote_ops
.to_static_tracepoint_markers_by_strid
13605 = remote_static_tracepoint_markers_by_strid
;
13606 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
13607 remote_ops
.to_use_agent
= remote_use_agent
;
13608 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
13609 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
13610 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
13611 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
13612 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
13613 remote_ops
.to_read_btrace
= remote_read_btrace
;
13614 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
13615 remote_ops
.to_augmented_libraries_svr4_read
=
13616 remote_augmented_libraries_svr4_read
;
13617 remote_ops
.to_follow_fork
= remote_follow_fork
;
13618 remote_ops
.to_follow_exec
= remote_follow_exec
;
13619 remote_ops
.to_insert_fork_catchpoint
= remote_insert_fork_catchpoint
;
13620 remote_ops
.to_remove_fork_catchpoint
= remote_remove_fork_catchpoint
;
13621 remote_ops
.to_insert_vfork_catchpoint
= remote_insert_vfork_catchpoint
;
13622 remote_ops
.to_remove_vfork_catchpoint
= remote_remove_vfork_catchpoint
;
13623 remote_ops
.to_insert_exec_catchpoint
= remote_insert_exec_catchpoint
;
13624 remote_ops
.to_remove_exec_catchpoint
= remote_remove_exec_catchpoint
;
13625 remote_ops
.to_execution_direction
= remote_execution_direction
;
13628 /* Set up the extended remote vector by making a copy of the standard
13629 remote vector and adding to it. */
13632 init_extended_remote_ops (void)
13634 extended_remote_ops
= remote_ops
;
13636 extended_remote_ops
.to_shortname
= "extended-remote";
13637 extended_remote_ops
.to_longname
=
13638 "Extended remote serial target in gdb-specific protocol";
13639 extended_remote_ops
.to_doc
=
13640 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13641 Specify the serial device it is connected to (e.g. /dev/ttya).";
13642 extended_remote_ops
.to_open
= extended_remote_open
;
13643 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
13644 extended_remote_ops
.to_detach
= extended_remote_detach
;
13645 extended_remote_ops
.to_attach
= extended_remote_attach
;
13646 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
13647 extended_remote_ops
.to_supports_disable_randomization
13648 = extended_remote_supports_disable_randomization
;
13652 remote_can_async_p (struct target_ops
*ops
)
13654 struct remote_state
*rs
= get_remote_state ();
13656 if (!target_async_permitted
)
13657 /* We only enable async when the user specifically asks for it. */
13660 /* We're async whenever the serial device is. */
13661 return serial_can_async_p (rs
->remote_desc
);
13665 remote_is_async_p (struct target_ops
*ops
)
13667 struct remote_state
*rs
= get_remote_state ();
13669 if (!target_async_permitted
)
13670 /* We only enable async when the user specifically asks for it. */
13673 /* We're async whenever the serial device is. */
13674 return serial_is_async_p (rs
->remote_desc
);
13677 /* Pass the SERIAL event on and up to the client. One day this code
13678 will be able to delay notifying the client of an event until the
13679 point where an entire packet has been received. */
13681 static serial_event_ftype remote_async_serial_handler
;
13684 remote_async_serial_handler (struct serial
*scb
, void *context
)
13686 /* Don't propogate error information up to the client. Instead let
13687 the client find out about the error by querying the target. */
13688 inferior_event_handler (INF_REG_EVENT
, NULL
);
13692 remote_async_inferior_event_handler (gdb_client_data data
)
13694 inferior_event_handler (INF_REG_EVENT
, NULL
);
13698 remote_async (struct target_ops
*ops
, int enable
)
13700 struct remote_state
*rs
= get_remote_state ();
13704 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
13706 /* If there are pending events in the stop reply queue tell the
13707 event loop to process them. */
13708 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
13709 mark_async_event_handler (remote_async_inferior_event_token
);
13710 /* For simplicity, below we clear the pending events token
13711 without remembering whether it is marked, so here we always
13712 mark it. If there's actually no pending notification to
13713 process, this ends up being a no-op (other than a spurious
13714 event-loop wakeup). */
13715 if (target_is_non_stop_p ())
13716 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13720 serial_async (rs
->remote_desc
, NULL
, NULL
);
13721 /* If the core is disabling async, it doesn't want to be
13722 disturbed with target events. Clear all async event sources
13724 clear_async_event_handler (remote_async_inferior_event_token
);
13725 if (target_is_non_stop_p ())
13726 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13730 /* Implementation of the to_thread_events method. */
13733 remote_thread_events (struct target_ops
*ops
, int enable
)
13735 struct remote_state
*rs
= get_remote_state ();
13736 size_t size
= get_remote_packet_size ();
13738 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
13741 xsnprintf (rs
->buf
, size
, "QThreadEvents:%x", enable
? 1 : 0);
13743 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13745 switch (packet_ok (rs
->buf
,
13746 &remote_protocol_packets
[PACKET_QThreadEvents
]))
13749 if (strcmp (rs
->buf
, "OK") != 0)
13750 error (_("Remote refused setting thread events: %s"), rs
->buf
);
13753 warning (_("Remote failure reply: %s"), rs
->buf
);
13755 case PACKET_UNKNOWN
:
13761 set_remote_cmd (char *args
, int from_tty
)
13763 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
13767 show_remote_cmd (char *args
, int from_tty
)
13769 /* We can't just use cmd_show_list here, because we want to skip
13770 the redundant "show remote Z-packet" and the legacy aliases. */
13771 struct cleanup
*showlist_chain
;
13772 struct cmd_list_element
*list
= remote_show_cmdlist
;
13773 struct ui_out
*uiout
= current_uiout
;
13775 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
13776 for (; list
!= NULL
; list
= list
->next
)
13777 if (strcmp (list
->name
, "Z-packet") == 0)
13779 else if (list
->type
== not_set_cmd
)
13780 /* Alias commands are exactly like the original, except they
13781 don't have the normal type. */
13785 struct cleanup
*option_chain
13786 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
13788 uiout
->field_string ("name", list
->name
);
13789 uiout
->text (": ");
13790 if (list
->type
== show_cmd
)
13791 do_show_command (NULL
, from_tty
, list
);
13793 cmd_func (list
, NULL
, from_tty
);
13794 /* Close the tuple. */
13795 do_cleanups (option_chain
);
13798 /* Close the tuple. */
13799 do_cleanups (showlist_chain
);
13803 /* Function to be called whenever a new objfile (shlib) is detected. */
13805 remote_new_objfile (struct objfile
*objfile
)
13807 struct remote_state
*rs
= get_remote_state ();
13809 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
13810 remote_check_symbols ();
13813 /* Pull all the tracepoints defined on the target and create local
13814 data structures representing them. We don't want to create real
13815 tracepoints yet, we don't want to mess up the user's existing
13819 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
13821 struct remote_state
*rs
= get_remote_state ();
13824 /* Ask for a first packet of tracepoint definition. */
13826 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13828 while (*p
&& *p
!= 'l')
13830 parse_tracepoint_definition (p
, utpp
);
13831 /* Ask for another packet of tracepoint definition. */
13833 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13840 remote_upload_trace_state_variables (struct target_ops
*self
,
13841 struct uploaded_tsv
**utsvp
)
13843 struct remote_state
*rs
= get_remote_state ();
13846 /* Ask for a first packet of variable definition. */
13848 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13850 while (*p
&& *p
!= 'l')
13852 parse_tsv_definition (p
, utsvp
);
13853 /* Ask for another packet of variable definition. */
13855 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13861 /* The "set/show range-stepping" show hook. */
13864 show_range_stepping (struct ui_file
*file
, int from_tty
,
13865 struct cmd_list_element
*c
,
13868 fprintf_filtered (file
,
13869 _("Debugger's willingness to use range stepping "
13870 "is %s.\n"), value
);
13873 /* The "set/show range-stepping" set hook. */
13876 set_range_stepping (char *ignore_args
, int from_tty
,
13877 struct cmd_list_element
*c
)
13879 struct remote_state
*rs
= get_remote_state ();
13881 /* Whene enabling, check whether range stepping is actually
13882 supported by the target, and warn if not. */
13883 if (use_range_stepping
)
13885 if (rs
->remote_desc
!= NULL
)
13887 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13888 remote_vcont_probe (rs
);
13890 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
13891 && rs
->supports_vCont
.r
)
13895 warning (_("Range stepping is not supported by the current target"));
13900 _initialize_remote (void)
13902 struct cmd_list_element
*cmd
;
13903 const char *cmd_name
;
13905 /* architecture specific data */
13906 remote_gdbarch_data_handle
=
13907 gdbarch_data_register_post_init (init_remote_state
);
13908 remote_g_packet_data_handle
=
13909 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
13912 = register_program_space_data_with_cleanup (NULL
,
13913 remote_pspace_data_cleanup
);
13915 /* Initialize the per-target state. At the moment there is only one
13916 of these, not one per target. Only one target is active at a
13918 remote_state
= new_remote_state ();
13920 init_remote_ops ();
13921 add_target (&remote_ops
);
13923 init_extended_remote_ops ();
13924 add_target (&extended_remote_ops
);
13926 /* Hook into new objfile notification. */
13927 observer_attach_new_objfile (remote_new_objfile
);
13928 /* We're no longer interested in notification events of an inferior
13930 observer_attach_inferior_exit (discard_pending_stop_replies
);
13933 init_remote_threadtests ();
13936 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
13937 /* set/show remote ... */
13939 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
13940 Remote protocol specific variables\n\
13941 Configure various remote-protocol specific variables such as\n\
13942 the packets being used"),
13943 &remote_set_cmdlist
, "set remote ",
13944 0 /* allow-unknown */, &setlist
);
13945 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
13946 Remote protocol specific variables\n\
13947 Configure various remote-protocol specific variables such as\n\
13948 the packets being used"),
13949 &remote_show_cmdlist
, "show remote ",
13950 0 /* allow-unknown */, &showlist
);
13952 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
13953 Compare section data on target to the exec file.\n\
13954 Argument is a single section name (default: all loaded sections).\n\
13955 To compare only read-only loaded sections, specify the -r option."),
13958 add_cmd ("packet", class_maintenance
, packet_command
, _("\
13959 Send an arbitrary packet to a remote target.\n\
13960 maintenance packet TEXT\n\
13961 If GDB is talking to an inferior via the GDB serial protocol, then\n\
13962 this command sends the string TEXT to the inferior, and displays the\n\
13963 response packet. GDB supplies the initial `$' character, and the\n\
13964 terminating `#' character and checksum."),
13967 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
13968 Set whether to send break if interrupted."), _("\
13969 Show whether to send break if interrupted."), _("\
13970 If set, a break, instead of a cntrl-c, is sent to the remote target."),
13971 set_remotebreak
, show_remotebreak
,
13972 &setlist
, &showlist
);
13973 cmd_name
= "remotebreak";
13974 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
13975 deprecate_cmd (cmd
, "set remote interrupt-sequence");
13976 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
13977 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
13978 deprecate_cmd (cmd
, "show remote interrupt-sequence");
13980 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
13981 interrupt_sequence_modes
, &interrupt_sequence_mode
,
13983 Set interrupt sequence to remote target."), _("\
13984 Show interrupt sequence to remote target."), _("\
13985 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
13986 NULL
, show_interrupt_sequence
,
13987 &remote_set_cmdlist
,
13988 &remote_show_cmdlist
);
13990 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
13991 &interrupt_on_connect
, _("\
13992 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
13993 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
13994 If set, interrupt sequence is sent to remote target."),
13996 &remote_set_cmdlist
, &remote_show_cmdlist
);
13998 /* Install commands for configuring memory read/write packets. */
14000 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14001 Set the maximum number of bytes per memory write packet (deprecated)."),
14003 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14004 Show the maximum number of bytes per memory write packet (deprecated)."),
14006 add_cmd ("memory-write-packet-size", no_class
,
14007 set_memory_write_packet_size
, _("\
14008 Set the maximum number of bytes per memory-write packet.\n\
14009 Specify the number of bytes in a packet or 0 (zero) for the\n\
14010 default packet size. The actual limit is further reduced\n\
14011 dependent on the target. Specify ``fixed'' to disable the\n\
14012 further restriction and ``limit'' to enable that restriction."),
14013 &remote_set_cmdlist
);
14014 add_cmd ("memory-read-packet-size", no_class
,
14015 set_memory_read_packet_size
, _("\
14016 Set the maximum number of bytes per memory-read packet.\n\
14017 Specify the number of bytes in a packet or 0 (zero) for the\n\
14018 default packet size. The actual limit is further reduced\n\
14019 dependent on the target. Specify ``fixed'' to disable the\n\
14020 further restriction and ``limit'' to enable that restriction."),
14021 &remote_set_cmdlist
);
14022 add_cmd ("memory-write-packet-size", no_class
,
14023 show_memory_write_packet_size
,
14024 _("Show the maximum number of bytes per memory-write packet."),
14025 &remote_show_cmdlist
);
14026 add_cmd ("memory-read-packet-size", no_class
,
14027 show_memory_read_packet_size
,
14028 _("Show the maximum number of bytes per memory-read packet."),
14029 &remote_show_cmdlist
);
14031 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
14032 &remote_hw_watchpoint_limit
, _("\
14033 Set the maximum number of target hardware watchpoints."), _("\
14034 Show the maximum number of target hardware watchpoints."), _("\
14035 Specify a negative limit for unlimited."),
14036 NULL
, NULL
, /* FIXME: i18n: The maximum
14037 number of target hardware
14038 watchpoints is %s. */
14039 &remote_set_cmdlist
, &remote_show_cmdlist
);
14040 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
14041 &remote_hw_watchpoint_length_limit
, _("\
14042 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14043 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14044 Specify a negative limit for unlimited."),
14045 NULL
, NULL
, /* FIXME: i18n: The maximum
14046 length (in bytes) of a target
14047 hardware watchpoint is %s. */
14048 &remote_set_cmdlist
, &remote_show_cmdlist
);
14049 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
14050 &remote_hw_breakpoint_limit
, _("\
14051 Set the maximum number of target hardware breakpoints."), _("\
14052 Show the maximum number of target hardware breakpoints."), _("\
14053 Specify a negative limit for unlimited."),
14054 NULL
, NULL
, /* FIXME: i18n: The maximum
14055 number of target hardware
14056 breakpoints is %s. */
14057 &remote_set_cmdlist
, &remote_show_cmdlist
);
14059 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14060 &remote_address_size
, _("\
14061 Set the maximum size of the address (in bits) in a memory packet."), _("\
14062 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14064 NULL
, /* FIXME: i18n: */
14065 &setlist
, &showlist
);
14067 init_all_packet_configs ();
14069 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14070 "X", "binary-download", 1);
14072 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14073 "vCont", "verbose-resume", 0);
14075 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14076 "QPassSignals", "pass-signals", 0);
14078 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14079 "QCatchSyscalls", "catch-syscalls", 0);
14081 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14082 "QProgramSignals", "program-signals", 0);
14084 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14085 "qSymbol", "symbol-lookup", 0);
14087 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14088 "P", "set-register", 1);
14090 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14091 "p", "fetch-register", 1);
14093 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14094 "Z0", "software-breakpoint", 0);
14096 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14097 "Z1", "hardware-breakpoint", 0);
14099 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14100 "Z2", "write-watchpoint", 0);
14102 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14103 "Z3", "read-watchpoint", 0);
14105 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14106 "Z4", "access-watchpoint", 0);
14108 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14109 "qXfer:auxv:read", "read-aux-vector", 0);
14111 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14112 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14114 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14115 "qXfer:features:read", "target-features", 0);
14117 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14118 "qXfer:libraries:read", "library-info", 0);
14120 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14121 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14123 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14124 "qXfer:memory-map:read", "memory-map", 0);
14126 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14127 "qXfer:spu:read", "read-spu-object", 0);
14129 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14130 "qXfer:spu:write", "write-spu-object", 0);
14132 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14133 "qXfer:osdata:read", "osdata", 0);
14135 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14136 "qXfer:threads:read", "threads", 0);
14138 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14139 "qXfer:siginfo:read", "read-siginfo-object", 0);
14141 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14142 "qXfer:siginfo:write", "write-siginfo-object", 0);
14144 add_packet_config_cmd
14145 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14146 "qXfer:traceframe-info:read", "traceframe-info", 0);
14148 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14149 "qXfer:uib:read", "unwind-info-block", 0);
14151 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14152 "qGetTLSAddr", "get-thread-local-storage-address",
14155 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14156 "qGetTIBAddr", "get-thread-information-block-address",
14159 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14160 "bc", "reverse-continue", 0);
14162 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14163 "bs", "reverse-step", 0);
14165 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14166 "qSupported", "supported-packets", 0);
14168 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14169 "qSearch:memory", "search-memory", 0);
14171 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14172 "qTStatus", "trace-status", 0);
14174 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14175 "vFile:setfs", "hostio-setfs", 0);
14177 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14178 "vFile:open", "hostio-open", 0);
14180 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14181 "vFile:pread", "hostio-pread", 0);
14183 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14184 "vFile:pwrite", "hostio-pwrite", 0);
14186 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14187 "vFile:close", "hostio-close", 0);
14189 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14190 "vFile:unlink", "hostio-unlink", 0);
14192 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14193 "vFile:readlink", "hostio-readlink", 0);
14195 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14196 "vFile:fstat", "hostio-fstat", 0);
14198 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14199 "vAttach", "attach", 0);
14201 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14204 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14205 "QStartNoAckMode", "noack", 0);
14207 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14208 "vKill", "kill", 0);
14210 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14211 "qAttached", "query-attached", 0);
14213 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14214 "ConditionalTracepoints",
14215 "conditional-tracepoints", 0);
14217 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14218 "ConditionalBreakpoints",
14219 "conditional-breakpoints", 0);
14221 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14222 "BreakpointCommands",
14223 "breakpoint-commands", 0);
14225 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14226 "FastTracepoints", "fast-tracepoints", 0);
14228 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14229 "TracepointSource", "TracepointSource", 0);
14231 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14232 "QAllow", "allow", 0);
14234 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14235 "StaticTracepoints", "static-tracepoints", 0);
14237 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14238 "InstallInTrace", "install-in-trace", 0);
14240 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14241 "qXfer:statictrace:read", "read-sdata-object", 0);
14243 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14244 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14246 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14247 "QDisableRandomization", "disable-randomization", 0);
14249 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14250 "QAgent", "agent", 0);
14252 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14253 "QTBuffer:size", "trace-buffer-size", 0);
14255 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14256 "Qbtrace:off", "disable-btrace", 0);
14258 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14259 "Qbtrace:bts", "enable-btrace-bts", 0);
14261 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14262 "Qbtrace:pt", "enable-btrace-pt", 0);
14264 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14265 "qXfer:btrace", "read-btrace", 0);
14267 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14268 "qXfer:btrace-conf", "read-btrace-conf", 0);
14270 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14271 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14273 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14274 "multiprocess-feature", "multiprocess-feature", 0);
14276 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14277 "swbreak-feature", "swbreak-feature", 0);
14279 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14280 "hwbreak-feature", "hwbreak-feature", 0);
14282 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14283 "fork-event-feature", "fork-event-feature", 0);
14285 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14286 "vfork-event-feature", "vfork-event-feature", 0);
14288 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14289 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14291 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14292 "vContSupported", "verbose-resume-supported", 0);
14294 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14295 "exec-event-feature", "exec-event-feature", 0);
14297 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14298 "vCtrlC", "ctrl-c", 0);
14300 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14301 "QThreadEvents", "thread-events", 0);
14303 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14304 "N stop reply", "no-resumed-stop-reply", 0);
14306 /* Assert that we've registered "set remote foo-packet" commands
14307 for all packet configs. */
14311 for (i
= 0; i
< PACKET_MAX
; i
++)
14313 /* Ideally all configs would have a command associated. Some
14314 still don't though. */
14319 case PACKET_QNonStop
:
14320 case PACKET_EnableDisableTracepoints_feature
:
14321 case PACKET_tracenz_feature
:
14322 case PACKET_DisconnectedTracing_feature
:
14323 case PACKET_augmented_libraries_svr4_read_feature
:
14325 /* Additions to this list need to be well justified:
14326 pre-existing packets are OK; new packets are not. */
14334 /* This catches both forgetting to add a config command, and
14335 forgetting to remove a packet from the exception list. */
14336 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14340 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14341 Z sub-packet has its own set and show commands, but users may
14342 have sets to this variable in their .gdbinit files (or in their
14344 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14345 &remote_Z_packet_detect
, _("\
14346 Set use of remote protocol `Z' packets"), _("\
14347 Show use of remote protocol `Z' packets "), _("\
14348 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14350 set_remote_protocol_Z_packet_cmd
,
14351 show_remote_protocol_Z_packet_cmd
,
14352 /* FIXME: i18n: Use of remote protocol
14353 `Z' packets is %s. */
14354 &remote_set_cmdlist
, &remote_show_cmdlist
);
14356 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14357 Manipulate files on the remote system\n\
14358 Transfer files to and from the remote target system."),
14359 &remote_cmdlist
, "remote ",
14360 0 /* allow-unknown */, &cmdlist
);
14362 add_cmd ("put", class_files
, remote_put_command
,
14363 _("Copy a local file to the remote system."),
14366 add_cmd ("get", class_files
, remote_get_command
,
14367 _("Copy a remote file to the local system."),
14370 add_cmd ("delete", class_files
, remote_delete_command
,
14371 _("Delete a remote file."),
14374 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14375 &remote_exec_file_var
, _("\
14376 Set the remote pathname for \"run\""), _("\
14377 Show the remote pathname for \"run\""), NULL
,
14378 set_remote_exec_file
,
14379 show_remote_exec_file
,
14380 &remote_set_cmdlist
,
14381 &remote_show_cmdlist
);
14383 add_setshow_boolean_cmd ("range-stepping", class_run
,
14384 &use_range_stepping
, _("\
14385 Enable or disable range stepping."), _("\
14386 Show whether target-assisted range stepping is enabled."), _("\
14387 If on, and the target supports it, when stepping a source line, GDB\n\
14388 tells the target to step the corresponding range of addresses itself instead\n\
14389 of issuing multiple single-steps. This speeds up source level\n\
14390 stepping. If off, GDB always issues single-steps, even if range\n\
14391 stepping is supported by the target. The default is on."),
14392 set_range_stepping
,
14393 show_range_stepping
,
14397 /* Eventually initialize fileio. See fileio.c */
14398 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
14400 /* Take advantage of the fact that the TID field is not used, to tag
14401 special ptids with it set to != 0. */
14402 magic_null_ptid
= ptid_build (42000, -1, 1);
14403 not_sent_ptid
= ptid_build (42000, -2, 1);
14404 any_thread_ptid
= ptid_build (42000, 0, 1);
14406 target_buf_size
= 2048;
14407 target_buf
= (char *) xmalloc (target_buf_size
);