1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2015 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 "event-loop.h"
51 #include "event-top.h"
57 #include "gdbcore.h" /* for exec_bfd */
59 #include "remote-fileio.h"
60 #include "gdb/fileio.h"
62 #include "xml-support.h"
64 #include "memory-map.h"
66 #include "tracepoint.h"
72 /* Temp hacks for tracepoint encoding migration. */
73 static char *target_buf
;
74 static long target_buf_size
;
76 /* The size to align memory write packets, when practical. The protocol
77 does not guarantee any alignment, and gdb will generate short
78 writes and unaligned writes, but even as a best-effort attempt this
79 can improve bulk transfers. For instance, if a write is misaligned
80 relative to the target's data bus, the stub may need to make an extra
81 round trip fetching data from the target. This doesn't make a
82 huge difference, but it's easy to do, so we try to be helpful.
84 The alignment chosen is arbitrary; usually data bus width is
85 important here, not the possibly larger cache line size. */
86 enum { REMOTE_ALIGN_WRITES
= 16 };
88 /* Prototypes for local functions. */
89 static void async_cleanup_sigint_signal_handler (void *dummy
);
90 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
91 static int getpkt_or_notif_sane (char **buf
, long *sizeof_buf
,
92 int forever
, int *is_notif
);
94 static void async_handle_remote_sigint (int);
95 static void async_handle_remote_sigint_twice (int);
97 static void remote_files_info (struct target_ops
*ignore
);
99 static void remote_prepare_to_store (struct target_ops
*self
,
100 struct regcache
*regcache
);
102 static void remote_open_1 (const char *, int, struct target_ops
*,
105 static void remote_close (struct target_ops
*self
);
109 static int remote_vkill (int pid
, struct remote_state
*rs
);
111 static void remote_mourn (struct target_ops
*ops
);
113 static void extended_remote_restart (void);
115 static void extended_remote_mourn (struct target_ops
*);
117 static void remote_send (char **buf
, long *sizeof_buf_p
);
119 static int readchar (int timeout
);
121 static void remote_serial_write (const char *str
, int len
);
123 static void remote_kill (struct target_ops
*ops
);
125 static int remote_can_async_p (struct target_ops
*);
127 static int remote_is_async_p (struct target_ops
*);
129 static void remote_async (struct target_ops
*ops
, int enable
);
131 static void sync_remote_interrupt_twice (int signo
);
133 static void interrupt_query (void);
135 static void set_general_thread (struct ptid ptid
);
136 static void set_continue_thread (struct ptid ptid
);
138 static void get_offsets (void);
140 static void skip_frame (void);
142 static long read_frame (char **buf_p
, long *sizeof_buf
);
144 static int hexnumlen (ULONGEST num
);
146 static void init_remote_ops (void);
148 static void init_extended_remote_ops (void);
150 static void remote_stop (struct target_ops
*self
, ptid_t
);
152 static int stubhex (int ch
);
154 static int hexnumstr (char *, ULONGEST
);
156 static int hexnumnstr (char *, ULONGEST
, int);
158 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
160 static void print_packet (const char *);
162 static void compare_sections_command (char *, int);
164 static void packet_command (char *, int);
166 static int stub_unpack_int (char *buff
, int fieldlength
);
168 static ptid_t
remote_current_thread (ptid_t oldptid
);
170 static int putpkt_binary (const char *buf
, int cnt
);
172 static void check_binary_download (CORE_ADDR addr
);
174 struct packet_config
;
176 static void show_packet_config_cmd (struct packet_config
*config
);
178 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
180 struct cmd_list_element
*c
,
183 static char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
184 static ptid_t
read_ptid (char *buf
, char **obuf
);
186 static void remote_set_permissions (struct target_ops
*self
);
188 static int remote_get_trace_status (struct target_ops
*self
,
189 struct trace_status
*ts
);
191 static int remote_upload_tracepoints (struct target_ops
*self
,
192 struct uploaded_tp
**utpp
);
194 static int remote_upload_trace_state_variables (struct target_ops
*self
,
195 struct uploaded_tsv
**utsvp
);
197 static void remote_query_supported (void);
199 static void remote_check_symbols (void);
201 void _initialize_remote (void);
204 static void stop_reply_xfree (struct stop_reply
*);
205 static void remote_parse_stop_reply (char *, struct stop_reply
*);
206 static void push_stop_reply (struct stop_reply
*);
207 static void discard_pending_stop_replies_in_queue (struct remote_state
*);
208 static int peek_stop_reply (ptid_t ptid
);
210 struct threads_listing_context
;
211 static void remove_new_fork_children (struct threads_listing_context
*);
213 static void remote_async_inferior_event_handler (gdb_client_data
);
215 static void remote_terminal_ours (struct target_ops
*self
);
217 static int remote_read_description_p (struct target_ops
*target
);
219 static void remote_console_output (char *msg
);
221 static int remote_supports_cond_breakpoints (struct target_ops
*self
);
223 static int remote_can_run_breakpoint_commands (struct target_ops
*self
);
225 static void remote_btrace_reset (void);
229 static struct cmd_list_element
*remote_cmdlist
;
231 /* For "set remote" and "show remote". */
233 static struct cmd_list_element
*remote_set_cmdlist
;
234 static struct cmd_list_element
*remote_show_cmdlist
;
236 /* Stub vCont actions support.
238 Each field is a boolean flag indicating whether the stub reports
239 support for the corresponding action. */
241 struct vCont_action_support
250 /* Controls whether GDB is willing to use range stepping. */
252 static int use_range_stepping
= 1;
254 #define OPAQUETHREADBYTES 8
256 /* a 64 bit opaque identifier */
257 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
259 /* About this many threadisds fit in a packet. */
261 #define MAXTHREADLISTRESULTS 32
263 /* Description of the remote protocol state for the currently
264 connected target. This is per-target state, and independent of the
265 selected architecture. */
269 /* A buffer to use for incoming packets, and its current size. The
270 buffer is grown dynamically for larger incoming packets.
271 Outgoing packets may also be constructed in this buffer.
272 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
273 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
278 /* True if we're going through initial connection setup (finding out
279 about the remote side's threads, relocating symbols, etc.). */
282 /* If we negotiated packet size explicitly (and thus can bypass
283 heuristics for the largest packet size that will not overflow
284 a buffer in the stub), this will be set to that packet size.
285 Otherwise zero, meaning to use the guessed size. */
286 long explicit_packet_size
;
288 /* remote_wait is normally called when the target is running and
289 waits for a stop reply packet. But sometimes we need to call it
290 when the target is already stopped. We can send a "?" packet
291 and have remote_wait read the response. Or, if we already have
292 the response, we can stash it in BUF and tell remote_wait to
293 skip calling getpkt. This flag is set when BUF contains a
294 stop reply packet and the target is not waiting. */
295 int cached_wait_status
;
297 /* True, if in no ack mode. That is, neither GDB nor the stub will
298 expect acks from each other. The connection is assumed to be
302 /* True if we're connected in extended remote mode. */
305 /* True if we resumed the target and we're waiting for the target to
306 stop. In the mean time, we can't start another command/query.
307 The remote server wouldn't be ready to process it, so we'd
308 timeout waiting for a reply that would never come and eventually
309 we'd close the connection. This can happen in asynchronous mode
310 because we allow GDB commands while the target is running. */
311 int waiting_for_stop_reply
;
313 /* The status of the stub support for the various vCont actions. */
314 struct vCont_action_support supports_vCont
;
316 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
317 responded to that. */
320 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
321 remote_open knows that we don't have a file open when the program
323 struct serial
*remote_desc
;
325 /* These are the threads which we last sent to the remote system. The
326 TID member will be -1 for all or -2 for not sent yet. */
327 ptid_t general_thread
;
328 ptid_t continue_thread
;
330 /* This is the traceframe which we last selected on the remote system.
331 It will be -1 if no traceframe is selected. */
332 int remote_traceframe_number
;
334 char *last_pass_packet
;
336 /* The last QProgramSignals packet sent to the target. We bypass
337 sending a new program signals list down to the target if the new
338 packet is exactly the same as the last we sent. IOW, we only let
339 the target know about program signals list changes. */
340 char *last_program_signals_packet
;
342 enum gdb_signal last_sent_signal
;
346 char *finished_object
;
347 char *finished_annex
;
348 ULONGEST finished_offset
;
350 /* Should we try the 'ThreadInfo' query packet?
352 This variable (NOT available to the user: auto-detect only!)
353 determines whether GDB will use the new, simpler "ThreadInfo"
354 query or the older, more complex syntax for thread queries.
355 This is an auto-detect variable (set to true at each connect,
356 and set to false when the target fails to recognize it). */
357 int use_threadinfo_query
;
358 int use_threadextra_query
;
360 /* This is set to the data address of the access causing the target
361 to stop for a watchpoint. */
362 CORE_ADDR remote_watch_data_address
;
364 /* Whether the target stopped for a breakpoint/watchpoint. */
365 enum target_stop_reason stop_reason
;
367 threadref echo_nextthread
;
368 threadref nextthread
;
369 threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
371 /* The state of remote notification. */
372 struct remote_notif_state
*notif_state
;
374 /* The branch trace configuration. */
375 struct btrace_config btrace_config
;
377 /* The argument to the last "vFile:setfs:" packet we sent, used
378 to avoid sending repeated unnecessary "vFile:setfs:" packets.
379 Initialized to -1 to indicate that no "vFile:setfs:" packet
380 has yet been sent. */
384 /* Private data that we'll store in (struct thread_info)->private. */
385 struct private_thread_info
392 free_private_thread_info (struct private_thread_info
*info
)
398 /* This data could be associated with a target, but we do not always
399 have access to the current target when we need it, so for now it is
400 static. This will be fine for as long as only one target is in use
402 static struct remote_state
*remote_state
;
404 static struct remote_state
*
405 get_remote_state_raw (void)
410 /* Allocate a new struct remote_state with xmalloc, initialize it, and
413 static struct remote_state
*
414 new_remote_state (void)
416 struct remote_state
*result
= XCNEW (struct remote_state
);
418 /* The default buffer size is unimportant; it will be expanded
419 whenever a larger buffer is needed. */
420 result
->buf_size
= 400;
421 result
->buf
= xmalloc (result
->buf_size
);
422 result
->remote_traceframe_number
= -1;
423 result
->last_sent_signal
= GDB_SIGNAL_0
;
429 /* Description of the remote protocol for a given architecture. */
433 long offset
; /* Offset into G packet. */
434 long regnum
; /* GDB's internal register number. */
435 LONGEST pnum
; /* Remote protocol register number. */
436 int in_g_packet
; /* Always part of G packet. */
437 /* long size in bytes; == register_size (target_gdbarch (), regnum);
439 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
443 struct remote_arch_state
445 /* Description of the remote protocol registers. */
446 long sizeof_g_packet
;
448 /* Description of the remote protocol registers indexed by REGNUM
449 (making an array gdbarch_num_regs in size). */
450 struct packet_reg
*regs
;
452 /* This is the size (in chars) of the first response to the ``g''
453 packet. It is used as a heuristic when determining the maximum
454 size of memory-read and memory-write packets. A target will
455 typically only reserve a buffer large enough to hold the ``g''
456 packet. The size does not include packet overhead (headers and
458 long actual_register_packet_size
;
460 /* This is the maximum size (in chars) of a non read/write packet.
461 It is also used as a cap on the size of read/write packets. */
462 long remote_packet_size
;
465 /* Utility: generate error from an incoming stub packet. */
467 trace_error (char *buf
)
470 return; /* not an error msg */
473 case '1': /* malformed packet error */
474 if (*++buf
== '0') /* general case: */
475 error (_("remote.c: error in outgoing packet."));
477 error (_("remote.c: error in outgoing packet at field #%ld."),
478 strtol (buf
, NULL
, 16));
480 error (_("Target returns error code '%s'."), buf
);
484 /* Utility: wait for reply from stub, while accepting "O" packets. */
486 remote_get_noisy_reply (char **buf_p
,
489 do /* Loop on reply from remote stub. */
493 QUIT
; /* Allow user to bail out with ^C. */
494 getpkt (buf_p
, sizeof_buf
, 0);
498 else if (startswith (buf
, "qRelocInsn:"))
501 CORE_ADDR from
, to
, org_to
;
503 int adjusted_size
= 0;
506 p
= buf
+ strlen ("qRelocInsn:");
507 pp
= unpack_varlen_hex (p
, &ul
);
509 error (_("invalid qRelocInsn packet: %s"), buf
);
513 unpack_varlen_hex (p
, &ul
);
520 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
523 CATCH (ex
, RETURN_MASK_ALL
)
525 if (ex
.error
== MEMORY_ERROR
)
527 /* Propagate memory errors silently back to the
528 target. The stub may have limited the range of
529 addresses we can write to, for example. */
533 /* Something unexpectedly bad happened. Be verbose
534 so we can tell what, and propagate the error back
535 to the stub, so it doesn't get stuck waiting for
537 exception_fprintf (gdb_stderr
, ex
,
538 _("warning: relocating instruction: "));
546 adjusted_size
= to
- org_to
;
548 xsnprintf (buf
, *sizeof_buf
, "qRelocInsn:%x", adjusted_size
);
552 else if (buf
[0] == 'O' && buf
[1] != 'K')
553 remote_console_output (buf
+ 1); /* 'O' message from stub */
555 return buf
; /* Here's the actual reply. */
560 /* Handle for retreving the remote protocol data from gdbarch. */
561 static struct gdbarch_data
*remote_gdbarch_data_handle
;
563 static struct remote_arch_state
*
564 get_remote_arch_state (void)
566 return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle
);
569 /* Fetch the global remote target state. */
571 static struct remote_state
*
572 get_remote_state (void)
574 /* Make sure that the remote architecture state has been
575 initialized, because doing so might reallocate rs->buf. Any
576 function which calls getpkt also needs to be mindful of changes
577 to rs->buf, but this call limits the number of places which run
579 get_remote_arch_state ();
581 return get_remote_state_raw ();
585 compare_pnums (const void *lhs_
, const void *rhs_
)
587 const struct packet_reg
* const *lhs
= lhs_
;
588 const struct packet_reg
* const *rhs
= rhs_
;
590 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
592 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
599 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
601 int regnum
, num_remote_regs
, offset
;
602 struct packet_reg
**remote_regs
;
604 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
606 struct packet_reg
*r
= ®s
[regnum
];
608 if (register_size (gdbarch
, regnum
) == 0)
609 /* Do not try to fetch zero-sized (placeholder) registers. */
612 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
617 /* Define the g/G packet format as the contents of each register
618 with a remote protocol number, in order of ascending protocol
621 remote_regs
= alloca (gdbarch_num_regs (gdbarch
)
622 * sizeof (struct packet_reg
*));
623 for (num_remote_regs
= 0, regnum
= 0;
624 regnum
< gdbarch_num_regs (gdbarch
);
626 if (regs
[regnum
].pnum
!= -1)
627 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
629 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
632 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
634 remote_regs
[regnum
]->in_g_packet
= 1;
635 remote_regs
[regnum
]->offset
= offset
;
636 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
642 /* Given the architecture described by GDBARCH, return the remote
643 protocol register's number and the register's offset in the g/G
644 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
645 If the target does not have a mapping for REGNUM, return false,
646 otherwise, return true. */
649 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
650 int *pnum
, int *poffset
)
653 struct packet_reg
*regs
;
654 struct cleanup
*old_chain
;
656 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
658 regs
= xcalloc (gdbarch_num_regs (gdbarch
), sizeof (struct packet_reg
));
659 old_chain
= make_cleanup (xfree
, regs
);
661 sizeof_g_packet
= map_regcache_remote_table (gdbarch
, regs
);
663 *pnum
= regs
[regnum
].pnum
;
664 *poffset
= regs
[regnum
].offset
;
666 do_cleanups (old_chain
);
672 init_remote_state (struct gdbarch
*gdbarch
)
674 struct remote_state
*rs
= get_remote_state_raw ();
675 struct remote_arch_state
*rsa
;
677 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
679 /* Use the architecture to build a regnum<->pnum table, which will be
680 1:1 unless a feature set specifies otherwise. */
681 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
682 gdbarch_num_regs (gdbarch
),
685 /* Record the maximum possible size of the g packet - it may turn out
687 rsa
->sizeof_g_packet
= map_regcache_remote_table (gdbarch
, rsa
->regs
);
689 /* Default maximum number of characters in a packet body. Many
690 remote stubs have a hardwired buffer size of 400 bytes
691 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
692 as the maximum packet-size to ensure that the packet and an extra
693 NUL character can always fit in the buffer. This stops GDB
694 trashing stubs that try to squeeze an extra NUL into what is
695 already a full buffer (As of 1999-12-04 that was most stubs). */
696 rsa
->remote_packet_size
= 400 - 1;
698 /* This one is filled in when a ``g'' packet is received. */
699 rsa
->actual_register_packet_size
= 0;
701 /* Should rsa->sizeof_g_packet needs more space than the
702 default, adjust the size accordingly. Remember that each byte is
703 encoded as two characters. 32 is the overhead for the packet
704 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
705 (``$NN:G...#NN'') is a better guess, the below has been padded a
707 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
708 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
710 /* Make sure that the packet buffer is plenty big enough for
711 this architecture. */
712 if (rs
->buf_size
< rsa
->remote_packet_size
)
714 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
715 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
721 /* Return the current allowed size of a remote packet. This is
722 inferred from the current architecture, and should be used to
723 limit the length of outgoing packets. */
725 get_remote_packet_size (void)
727 struct remote_state
*rs
= get_remote_state ();
728 struct remote_arch_state
*rsa
= get_remote_arch_state ();
730 if (rs
->explicit_packet_size
)
731 return rs
->explicit_packet_size
;
733 return rsa
->remote_packet_size
;
736 static struct packet_reg
*
737 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
739 if (regnum
< 0 && regnum
>= gdbarch_num_regs (target_gdbarch ()))
743 struct packet_reg
*r
= &rsa
->regs
[regnum
];
745 gdb_assert (r
->regnum
== regnum
);
750 static struct packet_reg
*
751 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
755 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
757 struct packet_reg
*r
= &rsa
->regs
[i
];
765 static struct target_ops remote_ops
;
767 static struct target_ops extended_remote_ops
;
769 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
770 ``forever'' still use the normal timeout mechanism. This is
771 currently used by the ASYNC code to guarentee that target reads
772 during the initial connect always time-out. Once getpkt has been
773 modified to return a timeout indication and, in turn
774 remote_wait()/wait_for_inferior() have gained a timeout parameter
776 static int wait_forever_enabled_p
= 1;
778 /* Allow the user to specify what sequence to send to the remote
779 when he requests a program interruption: Although ^C is usually
780 what remote systems expect (this is the default, here), it is
781 sometimes preferable to send a break. On other systems such
782 as the Linux kernel, a break followed by g, which is Magic SysRq g
783 is required in order to interrupt the execution. */
784 const char interrupt_sequence_control_c
[] = "Ctrl-C";
785 const char interrupt_sequence_break
[] = "BREAK";
786 const char interrupt_sequence_break_g
[] = "BREAK-g";
787 static const char *const interrupt_sequence_modes
[] =
789 interrupt_sequence_control_c
,
790 interrupt_sequence_break
,
791 interrupt_sequence_break_g
,
794 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
797 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
798 struct cmd_list_element
*c
,
801 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
802 fprintf_filtered (file
,
803 _("Send the ASCII ETX character (Ctrl-c) "
804 "to the remote target to interrupt the "
805 "execution of the program.\n"));
806 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
807 fprintf_filtered (file
,
808 _("send a break signal to the remote target "
809 "to interrupt the execution of the program.\n"));
810 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
811 fprintf_filtered (file
,
812 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
813 "the remote target to interrupt the execution "
814 "of Linux kernel.\n"));
816 internal_error (__FILE__
, __LINE__
,
817 _("Invalid value for interrupt_sequence_mode: %s."),
818 interrupt_sequence_mode
);
821 /* This boolean variable specifies whether interrupt_sequence is sent
822 to the remote target when gdb connects to it.
823 This is mostly needed when you debug the Linux kernel: The Linux kernel
824 expects BREAK g which is Magic SysRq g for connecting gdb. */
825 static int interrupt_on_connect
= 0;
827 /* This variable is used to implement the "set/show remotebreak" commands.
828 Since these commands are now deprecated in favor of "set/show remote
829 interrupt-sequence", it no longer has any effect on the code. */
830 static int remote_break
;
833 set_remotebreak (char *args
, int from_tty
, struct cmd_list_element
*c
)
836 interrupt_sequence_mode
= interrupt_sequence_break
;
838 interrupt_sequence_mode
= interrupt_sequence_control_c
;
842 show_remotebreak (struct ui_file
*file
, int from_tty
,
843 struct cmd_list_element
*c
,
848 /* This variable sets the number of bits in an address that are to be
849 sent in a memory ("M" or "m") packet. Normally, after stripping
850 leading zeros, the entire address would be sent. This variable
851 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
852 initial implementation of remote.c restricted the address sent in
853 memory packets to ``host::sizeof long'' bytes - (typically 32
854 bits). Consequently, for 64 bit targets, the upper 32 bits of an
855 address was never sent. Since fixing this bug may cause a break in
856 some remote targets this variable is principly provided to
857 facilitate backward compatibility. */
859 static unsigned int remote_address_size
;
861 /* Temporary to track who currently owns the terminal. See
862 remote_terminal_* for more details. */
864 static int remote_async_terminal_ours_p
;
866 /* The executable file to use for "run" on the remote side. */
868 static char *remote_exec_file
= "";
871 /* User configurable variables for the number of characters in a
872 memory read/write packet. MIN (rsa->remote_packet_size,
873 rsa->sizeof_g_packet) is the default. Some targets need smaller
874 values (fifo overruns, et.al.) and some users need larger values
875 (speed up transfers). The variables ``preferred_*'' (the user
876 request), ``current_*'' (what was actually set) and ``forced_*''
877 (Positive - a soft limit, negative - a hard limit). */
879 struct memory_packet_config
886 /* Compute the current size of a read/write packet. Since this makes
887 use of ``actual_register_packet_size'' the computation is dynamic. */
890 get_memory_packet_size (struct memory_packet_config
*config
)
892 struct remote_state
*rs
= get_remote_state ();
893 struct remote_arch_state
*rsa
= get_remote_arch_state ();
895 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
896 law?) that some hosts don't cope very well with large alloca()
897 calls. Eventually the alloca() code will be replaced by calls to
898 xmalloc() and make_cleanups() allowing this restriction to either
899 be lifted or removed. */
900 #ifndef MAX_REMOTE_PACKET_SIZE
901 #define MAX_REMOTE_PACKET_SIZE 16384
903 /* NOTE: 20 ensures we can write at least one byte. */
904 #ifndef MIN_REMOTE_PACKET_SIZE
905 #define MIN_REMOTE_PACKET_SIZE 20
910 if (config
->size
<= 0)
911 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
913 what_they_get
= config
->size
;
917 what_they_get
= get_remote_packet_size ();
918 /* Limit the packet to the size specified by the user. */
920 && what_they_get
> config
->size
)
921 what_they_get
= config
->size
;
923 /* Limit it to the size of the targets ``g'' response unless we have
924 permission from the stub to use a larger packet size. */
925 if (rs
->explicit_packet_size
== 0
926 && rsa
->actual_register_packet_size
> 0
927 && what_they_get
> rsa
->actual_register_packet_size
)
928 what_they_get
= rsa
->actual_register_packet_size
;
930 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
931 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
932 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
933 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
935 /* Make sure there is room in the global buffer for this packet
936 (including its trailing NUL byte). */
937 if (rs
->buf_size
< what_they_get
+ 1)
939 rs
->buf_size
= 2 * what_they_get
;
940 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
943 return what_they_get
;
946 /* Update the size of a read/write packet. If they user wants
947 something really big then do a sanity check. */
950 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
952 int fixed_p
= config
->fixed_p
;
953 long size
= config
->size
;
956 error (_("Argument required (integer, `fixed' or `limited')."));
957 else if (strcmp (args
, "hard") == 0
958 || strcmp (args
, "fixed") == 0)
960 else if (strcmp (args
, "soft") == 0
961 || strcmp (args
, "limit") == 0)
967 size
= strtoul (args
, &end
, 0);
969 error (_("Invalid %s (bad syntax)."), config
->name
);
971 /* Instead of explicitly capping the size of a packet to
972 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
973 instead allowed to set the size to something arbitrarily
975 if (size
> MAX_REMOTE_PACKET_SIZE
)
976 error (_("Invalid %s (too large)."), config
->name
);
980 if (fixed_p
&& !config
->fixed_p
)
982 if (! query (_("The target may not be able to correctly handle a %s\n"
983 "of %ld bytes. Change the packet size? "),
985 error (_("Packet size not changed."));
987 /* Update the config. */
988 config
->fixed_p
= fixed_p
;
993 show_memory_packet_size (struct memory_packet_config
*config
)
995 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
997 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
998 get_memory_packet_size (config
));
1000 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1001 get_memory_packet_size (config
));
1004 static struct memory_packet_config memory_write_packet_config
=
1006 "memory-write-packet-size",
1010 set_memory_write_packet_size (char *args
, int from_tty
)
1012 set_memory_packet_size (args
, &memory_write_packet_config
);
1016 show_memory_write_packet_size (char *args
, int from_tty
)
1018 show_memory_packet_size (&memory_write_packet_config
);
1022 get_memory_write_packet_size (void)
1024 return get_memory_packet_size (&memory_write_packet_config
);
1027 static struct memory_packet_config memory_read_packet_config
=
1029 "memory-read-packet-size",
1033 set_memory_read_packet_size (char *args
, int from_tty
)
1035 set_memory_packet_size (args
, &memory_read_packet_config
);
1039 show_memory_read_packet_size (char *args
, int from_tty
)
1041 show_memory_packet_size (&memory_read_packet_config
);
1045 get_memory_read_packet_size (void)
1047 long size
= get_memory_packet_size (&memory_read_packet_config
);
1049 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1050 extra buffer size argument before the memory read size can be
1051 increased beyond this. */
1052 if (size
> get_remote_packet_size ())
1053 size
= get_remote_packet_size ();
1058 /* Generic configuration support for packets the stub optionally
1059 supports. Allows the user to specify the use of the packet as well
1060 as allowing GDB to auto-detect support in the remote stub. */
1064 PACKET_SUPPORT_UNKNOWN
= 0,
1069 struct packet_config
1074 /* If auto, GDB auto-detects support for this packet or feature,
1075 either through qSupported, or by trying the packet and looking
1076 at the response. If true, GDB assumes the target supports this
1077 packet. If false, the packet is disabled. Configs that don't
1078 have an associated command always have this set to auto. */
1079 enum auto_boolean detect
;
1081 /* Does the target support this packet? */
1082 enum packet_support support
;
1085 /* Analyze a packet's return value and update the packet config
1095 static enum packet_support
packet_config_support (struct packet_config
*config
);
1096 static enum packet_support
packet_support (int packet
);
1099 show_packet_config_cmd (struct packet_config
*config
)
1101 char *support
= "internal-error";
1103 switch (packet_config_support (config
))
1106 support
= "enabled";
1108 case PACKET_DISABLE
:
1109 support
= "disabled";
1111 case PACKET_SUPPORT_UNKNOWN
:
1112 support
= "unknown";
1115 switch (config
->detect
)
1117 case AUTO_BOOLEAN_AUTO
:
1118 printf_filtered (_("Support for the `%s' packet "
1119 "is auto-detected, currently %s.\n"),
1120 config
->name
, support
);
1122 case AUTO_BOOLEAN_TRUE
:
1123 case AUTO_BOOLEAN_FALSE
:
1124 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1125 config
->name
, support
);
1131 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1132 const char *title
, int legacy
)
1138 config
->name
= name
;
1139 config
->title
= title
;
1140 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1142 show_doc
= xstrprintf ("Show current use of remote "
1143 "protocol `%s' (%s) packet",
1145 /* set/show TITLE-packet {auto,on,off} */
1146 cmd_name
= xstrprintf ("%s-packet", title
);
1147 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1148 &config
->detect
, set_doc
,
1149 show_doc
, NULL
, /* help_doc */
1151 show_remote_protocol_packet_cmd
,
1152 &remote_set_cmdlist
, &remote_show_cmdlist
);
1153 /* The command code copies the documentation strings. */
1156 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1161 legacy_name
= xstrprintf ("%s-packet", name
);
1162 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1163 &remote_set_cmdlist
);
1164 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1165 &remote_show_cmdlist
);
1169 static enum packet_result
1170 packet_check_result (const char *buf
)
1174 /* The stub recognized the packet request. Check that the
1175 operation succeeded. */
1177 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1179 /* "Enn" - definitly an error. */
1180 return PACKET_ERROR
;
1182 /* Always treat "E." as an error. This will be used for
1183 more verbose error messages, such as E.memtypes. */
1184 if (buf
[0] == 'E' && buf
[1] == '.')
1185 return PACKET_ERROR
;
1187 /* The packet may or may not be OK. Just assume it is. */
1191 /* The stub does not support the packet. */
1192 return PACKET_UNKNOWN
;
1195 static enum packet_result
1196 packet_ok (const char *buf
, struct packet_config
*config
)
1198 enum packet_result result
;
1200 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1201 && config
->support
== PACKET_DISABLE
)
1202 internal_error (__FILE__
, __LINE__
,
1203 _("packet_ok: attempt to use a disabled packet"));
1205 result
= packet_check_result (buf
);
1210 /* The stub recognized the packet request. */
1211 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1214 fprintf_unfiltered (gdb_stdlog
,
1215 "Packet %s (%s) is supported\n",
1216 config
->name
, config
->title
);
1217 config
->support
= PACKET_ENABLE
;
1220 case PACKET_UNKNOWN
:
1221 /* The stub does not support the packet. */
1222 if (config
->detect
== AUTO_BOOLEAN_AUTO
1223 && config
->support
== PACKET_ENABLE
)
1225 /* If the stub previously indicated that the packet was
1226 supported then there is a protocol error. */
1227 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1228 config
->name
, config
->title
);
1230 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1232 /* The user set it wrong. */
1233 error (_("Enabled packet %s (%s) not recognized by stub"),
1234 config
->name
, config
->title
);
1238 fprintf_unfiltered (gdb_stdlog
,
1239 "Packet %s (%s) is NOT supported\n",
1240 config
->name
, config
->title
);
1241 config
->support
= PACKET_DISABLE
;
1262 PACKET_vFile_pwrite
,
1264 PACKET_vFile_unlink
,
1265 PACKET_vFile_readlink
,
1268 PACKET_qXfer_features
,
1269 PACKET_qXfer_exec_file
,
1270 PACKET_qXfer_libraries
,
1271 PACKET_qXfer_libraries_svr4
,
1272 PACKET_qXfer_memory_map
,
1273 PACKET_qXfer_spu_read
,
1274 PACKET_qXfer_spu_write
,
1275 PACKET_qXfer_osdata
,
1276 PACKET_qXfer_threads
,
1277 PACKET_qXfer_statictrace_read
,
1278 PACKET_qXfer_traceframe_info
,
1284 PACKET_QPassSignals
,
1285 PACKET_QProgramSignals
,
1287 PACKET_qSearch_memory
,
1290 PACKET_QStartNoAckMode
,
1292 PACKET_qXfer_siginfo_read
,
1293 PACKET_qXfer_siginfo_write
,
1296 /* Support for conditional tracepoints. */
1297 PACKET_ConditionalTracepoints
,
1299 /* Support for target-side breakpoint conditions. */
1300 PACKET_ConditionalBreakpoints
,
1302 /* Support for target-side breakpoint commands. */
1303 PACKET_BreakpointCommands
,
1305 /* Support for fast tracepoints. */
1306 PACKET_FastTracepoints
,
1308 /* Support for static tracepoints. */
1309 PACKET_StaticTracepoints
,
1311 /* Support for installing tracepoints while a trace experiment is
1313 PACKET_InstallInTrace
,
1317 PACKET_TracepointSource
,
1320 PACKET_QDisableRandomization
,
1322 PACKET_QTBuffer_size
,
1326 PACKET_qXfer_btrace
,
1328 /* Support for the QNonStop packet. */
1331 /* Support for multi-process extensions. */
1332 PACKET_multiprocess_feature
,
1334 /* Support for enabling and disabling tracepoints while a trace
1335 experiment is running. */
1336 PACKET_EnableDisableTracepoints_feature
,
1338 /* Support for collecting strings using the tracenz bytecode. */
1339 PACKET_tracenz_feature
,
1341 /* Support for continuing to run a trace experiment while GDB is
1343 PACKET_DisconnectedTracing_feature
,
1345 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
1346 PACKET_augmented_libraries_svr4_read_feature
,
1348 /* Support for the qXfer:btrace-conf:read packet. */
1349 PACKET_qXfer_btrace_conf
,
1351 /* Support for the Qbtrace-conf:bts:size packet. */
1352 PACKET_Qbtrace_conf_bts_size
,
1354 /* Support for swbreak+ feature. */
1355 PACKET_swbreak_feature
,
1357 /* Support for hwbreak+ feature. */
1358 PACKET_hwbreak_feature
,
1360 /* Support for fork events. */
1361 PACKET_fork_event_feature
,
1363 /* Support for vfork events. */
1364 PACKET_vfork_event_feature
,
1366 /* Support for the Qbtrace-conf:pt:size packet. */
1367 PACKET_Qbtrace_conf_pt_size
,
1372 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
1374 /* Returns the packet's corresponding "set remote foo-packet" command
1375 state. See struct packet_config for more details. */
1377 static enum auto_boolean
1378 packet_set_cmd_state (int packet
)
1380 return remote_protocol_packets
[packet
].detect
;
1383 /* Returns whether a given packet or feature is supported. This takes
1384 into account the state of the corresponding "set remote foo-packet"
1385 command, which may be used to bypass auto-detection. */
1387 static enum packet_support
1388 packet_config_support (struct packet_config
*config
)
1390 switch (config
->detect
)
1392 case AUTO_BOOLEAN_TRUE
:
1393 return PACKET_ENABLE
;
1394 case AUTO_BOOLEAN_FALSE
:
1395 return PACKET_DISABLE
;
1396 case AUTO_BOOLEAN_AUTO
:
1397 return config
->support
;
1399 gdb_assert_not_reached (_("bad switch"));
1403 /* Same as packet_config_support, but takes the packet's enum value as
1406 static enum packet_support
1407 packet_support (int packet
)
1409 struct packet_config
*config
= &remote_protocol_packets
[packet
];
1411 return packet_config_support (config
);
1415 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
1416 struct cmd_list_element
*c
,
1419 struct packet_config
*packet
;
1421 for (packet
= remote_protocol_packets
;
1422 packet
< &remote_protocol_packets
[PACKET_MAX
];
1425 if (&packet
->detect
== c
->var
)
1427 show_packet_config_cmd (packet
);
1431 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
1435 /* Should we try one of the 'Z' requests? */
1439 Z_PACKET_SOFTWARE_BP
,
1440 Z_PACKET_HARDWARE_BP
,
1447 /* For compatibility with older distributions. Provide a ``set remote
1448 Z-packet ...'' command that updates all the Z packet types. */
1450 static enum auto_boolean remote_Z_packet_detect
;
1453 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1454 struct cmd_list_element
*c
)
1458 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1459 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1463 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1464 struct cmd_list_element
*c
,
1469 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1471 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1475 /* Returns true if the multi-process extensions are in effect. */
1478 remote_multi_process_p (struct remote_state
*rs
)
1480 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
1483 /* Returns true if fork events are supported. */
1486 remote_fork_event_p (struct remote_state
*rs
)
1488 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
1491 /* Returns true if vfork events are supported. */
1494 remote_vfork_event_p (struct remote_state
*rs
)
1496 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
1499 /* Insert fork catchpoint target routine. If fork events are enabled
1500 then return success, nothing more to do. */
1503 remote_insert_fork_catchpoint (struct target_ops
*ops
, int pid
)
1505 struct remote_state
*rs
= get_remote_state ();
1507 return !remote_fork_event_p (rs
);
1510 /* Remove fork catchpoint target routine. Nothing to do, just
1514 remote_remove_fork_catchpoint (struct target_ops
*ops
, int pid
)
1519 /* Insert vfork catchpoint target routine. If vfork events are enabled
1520 then return success, nothing more to do. */
1523 remote_insert_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1525 struct remote_state
*rs
= get_remote_state ();
1527 return !remote_vfork_event_p (rs
);
1530 /* Remove vfork catchpoint target routine. Nothing to do, just
1534 remote_remove_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1539 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1540 static struct async_signal_handler
*async_sigint_remote_twice_token
;
1541 static struct async_signal_handler
*async_sigint_remote_token
;
1544 /* Asynchronous signal handle registered as event loop source for
1545 when we have pending events ready to be passed to the core. */
1547 static struct async_event_handler
*remote_async_inferior_event_token
;
1551 static ptid_t magic_null_ptid
;
1552 static ptid_t not_sent_ptid
;
1553 static ptid_t any_thread_ptid
;
1555 /* Find out if the stub attached to PID (and hence GDB should offer to
1556 detach instead of killing it when bailing out). */
1559 remote_query_attached (int pid
)
1561 struct remote_state
*rs
= get_remote_state ();
1562 size_t size
= get_remote_packet_size ();
1564 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
1567 if (remote_multi_process_p (rs
))
1568 xsnprintf (rs
->buf
, size
, "qAttached:%x", pid
);
1570 xsnprintf (rs
->buf
, size
, "qAttached");
1573 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1575 switch (packet_ok (rs
->buf
,
1576 &remote_protocol_packets
[PACKET_qAttached
]))
1579 if (strcmp (rs
->buf
, "1") == 0)
1583 warning (_("Remote failure reply: %s"), rs
->buf
);
1585 case PACKET_UNKNOWN
:
1592 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1593 has been invented by GDB, instead of reported by the target. Since
1594 we can be connected to a remote system before before knowing about
1595 any inferior, mark the target with execution when we find the first
1596 inferior. If ATTACHED is 1, then we had just attached to this
1597 inferior. If it is 0, then we just created this inferior. If it
1598 is -1, then try querying the remote stub to find out if it had
1599 attached to the inferior or not. If TRY_OPEN_EXEC is true then
1600 attempt to open this inferior's executable as the main executable
1601 if no main executable is open already. */
1603 static struct inferior
*
1604 remote_add_inferior (int fake_pid_p
, int pid
, int attached
,
1607 struct inferior
*inf
;
1609 /* Check whether this process we're learning about is to be
1610 considered attached, or if is to be considered to have been
1611 spawned by the stub. */
1613 attached
= remote_query_attached (pid
);
1615 if (gdbarch_has_global_solist (target_gdbarch ()))
1617 /* If the target shares code across all inferiors, then every
1618 attach adds a new inferior. */
1619 inf
= add_inferior (pid
);
1621 /* ... and every inferior is bound to the same program space.
1622 However, each inferior may still have its own address
1624 inf
->aspace
= maybe_new_address_space ();
1625 inf
->pspace
= current_program_space
;
1629 /* In the traditional debugging scenario, there's a 1-1 match
1630 between program/address spaces. We simply bind the inferior
1631 to the program space's address space. */
1632 inf
= current_inferior ();
1633 inferior_appeared (inf
, pid
);
1636 inf
->attach_flag
= attached
;
1637 inf
->fake_pid_p
= fake_pid_p
;
1639 /* If no main executable is currently open then attempt to
1640 open the file that was executed to create this inferior. */
1641 if (try_open_exec
&& get_exec_file (0) == NULL
)
1642 exec_file_locate_attach (pid
, 1);
1647 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1648 according to RUNNING. */
1651 remote_add_thread (ptid_t ptid
, int running
)
1653 struct remote_state
*rs
= get_remote_state ();
1655 /* GDB historically didn't pull threads in the initial connection
1656 setup. If the remote target doesn't even have a concept of
1657 threads (e.g., a bare-metal target), even if internally we
1658 consider that a single-threaded target, mentioning a new thread
1659 might be confusing to the user. Be silent then, preserving the
1660 age old behavior. */
1661 if (rs
->starting_up
)
1662 add_thread_silent (ptid
);
1666 set_executing (ptid
, running
);
1667 set_running (ptid
, running
);
1670 /* Come here when we learn about a thread id from the remote target.
1671 It may be the first time we hear about such thread, so take the
1672 opportunity to add it to GDB's thread list. In case this is the
1673 first time we're noticing its corresponding inferior, add it to
1674 GDB's inferior list as well. */
1677 remote_notice_new_inferior (ptid_t currthread
, int running
)
1679 /* If this is a new thread, add it to GDB's thread list.
1680 If we leave it up to WFI to do this, bad things will happen. */
1682 if (in_thread_list (currthread
) && is_exited (currthread
))
1684 /* We're seeing an event on a thread id we knew had exited.
1685 This has to be a new thread reusing the old id. Add it. */
1686 remote_add_thread (currthread
, running
);
1690 if (!in_thread_list (currthread
))
1692 struct inferior
*inf
= NULL
;
1693 int pid
= ptid_get_pid (currthread
);
1695 if (ptid_is_pid (inferior_ptid
)
1696 && pid
== ptid_get_pid (inferior_ptid
))
1698 /* inferior_ptid has no thread member yet. This can happen
1699 with the vAttach -> remote_wait,"TAAthread:" path if the
1700 stub doesn't support qC. This is the first stop reported
1701 after an attach, so this is the main thread. Update the
1702 ptid in the thread list. */
1703 if (in_thread_list (pid_to_ptid (pid
)))
1704 thread_change_ptid (inferior_ptid
, currthread
);
1707 remote_add_thread (currthread
, running
);
1708 inferior_ptid
= currthread
;
1713 if (ptid_equal (magic_null_ptid
, inferior_ptid
))
1715 /* inferior_ptid is not set yet. This can happen with the
1716 vRun -> remote_wait,"TAAthread:" path if the stub
1717 doesn't support qC. This is the first stop reported
1718 after an attach, so this is the main thread. Update the
1719 ptid in the thread list. */
1720 thread_change_ptid (inferior_ptid
, currthread
);
1724 /* When connecting to a target remote, or to a target
1725 extended-remote which already was debugging an inferior, we
1726 may not know about it yet. Add it before adding its child
1727 thread, so notifications are emitted in a sensible order. */
1728 if (!in_inferior_list (ptid_get_pid (currthread
)))
1730 struct remote_state
*rs
= get_remote_state ();
1731 int fake_pid_p
= !remote_multi_process_p (rs
);
1733 inf
= remote_add_inferior (fake_pid_p
,
1734 ptid_get_pid (currthread
), -1, 1);
1737 /* This is really a new thread. Add it. */
1738 remote_add_thread (currthread
, running
);
1740 /* If we found a new inferior, let the common code do whatever
1741 it needs to with it (e.g., read shared libraries, insert
1742 breakpoints), unless we're just setting up an all-stop
1746 struct remote_state
*rs
= get_remote_state ();
1748 if (non_stop
|| !rs
->starting_up
)
1749 notice_new_inferior (currthread
, running
, 0);
1754 /* Return the private thread data, creating it if necessary. */
1756 static struct private_thread_info
*
1757 demand_private_info (ptid_t ptid
)
1759 struct thread_info
*info
= find_thread_ptid (ptid
);
1765 info
->priv
= xmalloc (sizeof (*(info
->priv
)));
1766 info
->private_dtor
= free_private_thread_info
;
1767 info
->priv
->core
= -1;
1768 info
->priv
->extra
= 0;
1774 /* Call this function as a result of
1775 1) A halt indication (T packet) containing a thread id
1776 2) A direct query of currthread
1777 3) Successful execution of set thread */
1780 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
1782 rs
->general_thread
= currthread
;
1785 /* If 'QPassSignals' is supported, tell the remote stub what signals
1786 it can simply pass through to the inferior without reporting. */
1789 remote_pass_signals (struct target_ops
*self
,
1790 int numsigs
, unsigned char *pass_signals
)
1792 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
1794 char *pass_packet
, *p
;
1796 struct remote_state
*rs
= get_remote_state ();
1798 gdb_assert (numsigs
< 256);
1799 for (i
= 0; i
< numsigs
; i
++)
1801 if (pass_signals
[i
])
1804 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1805 strcpy (pass_packet
, "QPassSignals:");
1806 p
= pass_packet
+ strlen (pass_packet
);
1807 for (i
= 0; i
< numsigs
; i
++)
1809 if (pass_signals
[i
])
1812 *p
++ = tohex (i
>> 4);
1813 *p
++ = tohex (i
& 15);
1822 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
1824 putpkt (pass_packet
);
1825 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1826 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1827 if (rs
->last_pass_packet
)
1828 xfree (rs
->last_pass_packet
);
1829 rs
->last_pass_packet
= pass_packet
;
1832 xfree (pass_packet
);
1836 /* If 'QProgramSignals' is supported, tell the remote stub what
1837 signals it should pass through to the inferior when detaching. */
1840 remote_program_signals (struct target_ops
*self
,
1841 int numsigs
, unsigned char *signals
)
1843 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
1847 struct remote_state
*rs
= get_remote_state ();
1849 gdb_assert (numsigs
< 256);
1850 for (i
= 0; i
< numsigs
; i
++)
1855 packet
= xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
1856 strcpy (packet
, "QProgramSignals:");
1857 p
= packet
+ strlen (packet
);
1858 for (i
= 0; i
< numsigs
; i
++)
1860 if (signal_pass_state (i
))
1863 *p
++ = tohex (i
>> 4);
1864 *p
++ = tohex (i
& 15);
1873 if (!rs
->last_program_signals_packet
1874 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
1877 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1878 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
1879 xfree (rs
->last_program_signals_packet
);
1880 rs
->last_program_signals_packet
= packet
;
1887 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
1888 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1889 thread. If GEN is set, set the general thread, if not, then set
1890 the step/continue thread. */
1892 set_thread (struct ptid ptid
, int gen
)
1894 struct remote_state
*rs
= get_remote_state ();
1895 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
1896 char *buf
= rs
->buf
;
1897 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
1899 if (ptid_equal (state
, ptid
))
1903 *buf
++ = gen
? 'g' : 'c';
1904 if (ptid_equal (ptid
, magic_null_ptid
))
1905 xsnprintf (buf
, endbuf
- buf
, "0");
1906 else if (ptid_equal (ptid
, any_thread_ptid
))
1907 xsnprintf (buf
, endbuf
- buf
, "0");
1908 else if (ptid_equal (ptid
, minus_one_ptid
))
1909 xsnprintf (buf
, endbuf
- buf
, "-1");
1911 write_ptid (buf
, endbuf
, ptid
);
1913 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1915 rs
->general_thread
= ptid
;
1917 rs
->continue_thread
= ptid
;
1921 set_general_thread (struct ptid ptid
)
1923 set_thread (ptid
, 1);
1927 set_continue_thread (struct ptid ptid
)
1929 set_thread (ptid
, 0);
1932 /* Change the remote current process. Which thread within the process
1933 ends up selected isn't important, as long as it is the same process
1934 as what INFERIOR_PTID points to.
1936 This comes from that fact that there is no explicit notion of
1937 "selected process" in the protocol. The selected process for
1938 general operations is the process the selected general thread
1942 set_general_process (void)
1944 struct remote_state
*rs
= get_remote_state ();
1946 /* If the remote can't handle multiple processes, don't bother. */
1947 if (!rs
->extended
|| !remote_multi_process_p (rs
))
1950 /* We only need to change the remote current thread if it's pointing
1951 at some other process. */
1952 if (ptid_get_pid (rs
->general_thread
) != ptid_get_pid (inferior_ptid
))
1953 set_general_thread (inferior_ptid
);
1957 /* Return nonzero if this is the main thread that we made up ourselves
1958 to model non-threaded targets as single-threaded. */
1961 remote_thread_always_alive (struct target_ops
*ops
, ptid_t ptid
)
1963 struct remote_state
*rs
= get_remote_state ();
1966 if (ptid_equal (ptid
, magic_null_ptid
))
1967 /* The main thread is always alive. */
1970 if (ptid_get_pid (ptid
) != 0 && ptid_get_lwp (ptid
) == 0)
1971 /* The main thread is always alive. This can happen after a
1972 vAttach, if the remote side doesn't support
1979 /* Return nonzero if the thread PTID is still alive on the remote
1983 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1985 struct remote_state
*rs
= get_remote_state ();
1988 /* Check if this is a thread that we made up ourselves to model
1989 non-threaded targets as single-threaded. */
1990 if (remote_thread_always_alive (ops
, ptid
))
1994 endp
= rs
->buf
+ get_remote_packet_size ();
1997 write_ptid (p
, endp
, ptid
);
2000 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2001 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2004 /* About these extended threadlist and threadinfo packets. They are
2005 variable length packets but, the fields within them are often fixed
2006 length. They are redundent enough to send over UDP as is the
2007 remote protocol in general. There is a matching unit test module
2010 /* WARNING: This threadref data structure comes from the remote O.S.,
2011 libstub protocol encoding, and remote.c. It is not particularly
2014 /* Right now, the internal structure is int. We want it to be bigger.
2015 Plan to fix this. */
2017 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2019 /* gdb_ext_thread_info is an internal GDB data structure which is
2020 equivalent to the reply of the remote threadinfo packet. */
2022 struct gdb_ext_thread_info
2024 threadref threadid
; /* External form of thread reference. */
2025 int active
; /* Has state interesting to GDB?
2027 char display
[256]; /* Brief state display, name,
2028 blocked/suspended. */
2029 char shortname
[32]; /* To be used to name threads. */
2030 char more_display
[256]; /* Long info, statistics, queue depth,
2034 /* The volume of remote transfers can be limited by submitting
2035 a mask containing bits specifying the desired information.
2036 Use a union of these values as the 'selection' parameter to
2037 get_thread_info. FIXME: Make these TAG names more thread specific. */
2039 #define TAG_THREADID 1
2040 #define TAG_EXISTS 2
2041 #define TAG_DISPLAY 4
2042 #define TAG_THREADNAME 8
2043 #define TAG_MOREDISPLAY 16
2045 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2047 static char *unpack_nibble (char *buf
, int *val
);
2049 static char *unpack_byte (char *buf
, int *value
);
2051 static char *pack_int (char *buf
, int value
);
2053 static char *unpack_int (char *buf
, int *value
);
2055 static char *unpack_string (char *src
, char *dest
, int length
);
2057 static char *pack_threadid (char *pkt
, threadref
*id
);
2059 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2061 void int_to_threadref (threadref
*id
, int value
);
2063 static int threadref_to_int (threadref
*ref
);
2065 static void copy_threadref (threadref
*dest
, threadref
*src
);
2067 static int threadmatch (threadref
*dest
, threadref
*src
);
2069 static char *pack_threadinfo_request (char *pkt
, int mode
,
2072 static int remote_unpack_thread_info_response (char *pkt
,
2073 threadref
*expectedref
,
2074 struct gdb_ext_thread_info
2078 static int remote_get_threadinfo (threadref
*threadid
,
2079 int fieldset
, /*TAG mask */
2080 struct gdb_ext_thread_info
*info
);
2082 static char *pack_threadlist_request (char *pkt
, int startflag
,
2084 threadref
*nextthread
);
2086 static int parse_threadlist_response (char *pkt
,
2088 threadref
*original_echo
,
2089 threadref
*resultlist
,
2092 static int remote_get_threadlist (int startflag
,
2093 threadref
*nextthread
,
2097 threadref
*threadlist
);
2099 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
2101 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
2102 void *context
, int looplimit
);
2104 static int remote_newthread_step (threadref
*ref
, void *context
);
2107 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2108 buffer we're allowed to write to. Returns
2109 BUF+CHARACTERS_WRITTEN. */
2112 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2115 struct remote_state
*rs
= get_remote_state ();
2117 if (remote_multi_process_p (rs
))
2119 pid
= ptid_get_pid (ptid
);
2121 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2123 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2125 tid
= ptid_get_lwp (ptid
);
2127 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2129 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2134 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
2135 passed the last parsed char. Returns null_ptid on error. */
2138 read_ptid (char *buf
, char **obuf
)
2142 ULONGEST pid
= 0, tid
= 0;
2146 /* Multi-process ptid. */
2147 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2149 error (_("invalid remote ptid: %s"), p
);
2152 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2155 return ptid_build (pid
, tid
, 0);
2158 /* No multi-process. Just a tid. */
2159 pp
= unpack_varlen_hex (p
, &tid
);
2161 /* Since the stub is not sending a process id, then default to
2162 what's in inferior_ptid, unless it's null at this point. If so,
2163 then since there's no way to know the pid of the reported
2164 threads, use the magic number. */
2165 if (ptid_equal (inferior_ptid
, null_ptid
))
2166 pid
= ptid_get_pid (magic_null_ptid
);
2168 pid
= ptid_get_pid (inferior_ptid
);
2172 return ptid_build (pid
, tid
, 0);
2178 if (ch
>= 'a' && ch
<= 'f')
2179 return ch
- 'a' + 10;
2180 if (ch
>= '0' && ch
<= '9')
2182 if (ch
>= 'A' && ch
<= 'F')
2183 return ch
- 'A' + 10;
2188 stub_unpack_int (char *buff
, int fieldlength
)
2195 nibble
= stubhex (*buff
++);
2199 retval
= retval
<< 4;
2205 unpack_nibble (char *buf
, int *val
)
2207 *val
= fromhex (*buf
++);
2212 unpack_byte (char *buf
, int *value
)
2214 *value
= stub_unpack_int (buf
, 2);
2219 pack_int (char *buf
, int value
)
2221 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
2222 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
2223 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
2224 buf
= pack_hex_byte (buf
, (value
& 0xff));
2229 unpack_int (char *buf
, int *value
)
2231 *value
= stub_unpack_int (buf
, 8);
2235 #if 0 /* Currently unused, uncomment when needed. */
2236 static char *pack_string (char *pkt
, char *string
);
2239 pack_string (char *pkt
, char *string
)
2244 len
= strlen (string
);
2246 len
= 200; /* Bigger than most GDB packets, junk??? */
2247 pkt
= pack_hex_byte (pkt
, len
);
2251 if ((ch
== '\0') || (ch
== '#'))
2252 ch
= '*'; /* Protect encapsulation. */
2257 #endif /* 0 (unused) */
2260 unpack_string (char *src
, char *dest
, int length
)
2269 pack_threadid (char *pkt
, threadref
*id
)
2272 unsigned char *altid
;
2274 altid
= (unsigned char *) id
;
2275 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
2277 pkt
= pack_hex_byte (pkt
, *altid
++);
2283 unpack_threadid (char *inbuf
, threadref
*id
)
2286 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2289 altref
= (char *) id
;
2291 while (inbuf
< limit
)
2293 x
= stubhex (*inbuf
++);
2294 y
= stubhex (*inbuf
++);
2295 *altref
++ = (x
<< 4) | y
;
2300 /* Externally, threadrefs are 64 bits but internally, they are still
2301 ints. This is due to a mismatch of specifications. We would like
2302 to use 64bit thread references internally. This is an adapter
2306 int_to_threadref (threadref
*id
, int value
)
2308 unsigned char *scan
;
2310 scan
= (unsigned char *) id
;
2316 *scan
++ = (value
>> 24) & 0xff;
2317 *scan
++ = (value
>> 16) & 0xff;
2318 *scan
++ = (value
>> 8) & 0xff;
2319 *scan
++ = (value
& 0xff);
2323 threadref_to_int (threadref
*ref
)
2326 unsigned char *scan
;
2332 value
= (value
<< 8) | ((*scan
++) & 0xff);
2337 copy_threadref (threadref
*dest
, threadref
*src
)
2340 unsigned char *csrc
, *cdest
;
2342 csrc
= (unsigned char *) src
;
2343 cdest
= (unsigned char *) dest
;
2350 threadmatch (threadref
*dest
, threadref
*src
)
2352 /* Things are broken right now, so just assume we got a match. */
2354 unsigned char *srcp
, *destp
;
2356 srcp
= (char *) src
;
2357 destp
= (char *) dest
;
2361 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2368 threadid:1, # always request threadid
2375 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2378 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2380 *pkt
++ = 'q'; /* Info Query */
2381 *pkt
++ = 'P'; /* process or thread info */
2382 pkt
= pack_int (pkt
, mode
); /* mode */
2383 pkt
= pack_threadid (pkt
, id
); /* threadid */
2384 *pkt
= '\0'; /* terminate */
2388 /* These values tag the fields in a thread info response packet. */
2389 /* Tagging the fields allows us to request specific fields and to
2390 add more fields as time goes by. */
2392 #define TAG_THREADID 1 /* Echo the thread identifier. */
2393 #define TAG_EXISTS 2 /* Is this process defined enough to
2394 fetch registers and its stack? */
2395 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2396 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2397 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2401 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2402 struct gdb_ext_thread_info
*info
)
2404 struct remote_state
*rs
= get_remote_state ();
2408 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2411 /* info->threadid = 0; FIXME: implement zero_threadref. */
2413 info
->display
[0] = '\0';
2414 info
->shortname
[0] = '\0';
2415 info
->more_display
[0] = '\0';
2417 /* Assume the characters indicating the packet type have been
2419 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2420 pkt
= unpack_threadid (pkt
, &ref
);
2423 warning (_("Incomplete response to threadinfo request."));
2424 if (!threadmatch (&ref
, expectedref
))
2425 { /* This is an answer to a different request. */
2426 warning (_("ERROR RMT Thread info mismatch."));
2429 copy_threadref (&info
->threadid
, &ref
);
2431 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2433 /* Packets are terminated with nulls. */
2434 while ((pkt
< limit
) && mask
&& *pkt
)
2436 pkt
= unpack_int (pkt
, &tag
); /* tag */
2437 pkt
= unpack_byte (pkt
, &length
); /* length */
2438 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2440 warning (_("ERROR RMT: threadinfo tag mismatch."));
2444 if (tag
== TAG_THREADID
)
2448 warning (_("ERROR RMT: length of threadid is not 16."));
2452 pkt
= unpack_threadid (pkt
, &ref
);
2453 mask
= mask
& ~TAG_THREADID
;
2456 if (tag
== TAG_EXISTS
)
2458 info
->active
= stub_unpack_int (pkt
, length
);
2460 mask
= mask
& ~(TAG_EXISTS
);
2463 warning (_("ERROR RMT: 'exists' length too long."));
2469 if (tag
== TAG_THREADNAME
)
2471 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2472 mask
= mask
& ~TAG_THREADNAME
;
2475 if (tag
== TAG_DISPLAY
)
2477 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2478 mask
= mask
& ~TAG_DISPLAY
;
2481 if (tag
== TAG_MOREDISPLAY
)
2483 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2484 mask
= mask
& ~TAG_MOREDISPLAY
;
2487 warning (_("ERROR RMT: unknown thread info tag."));
2488 break; /* Not a tag we know about. */
2494 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2495 struct gdb_ext_thread_info
*info
)
2497 struct remote_state
*rs
= get_remote_state ();
2500 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2502 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2504 if (rs
->buf
[0] == '\0')
2507 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2512 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2515 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2516 threadref
*nextthread
)
2518 *pkt
++ = 'q'; /* info query packet */
2519 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2520 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2521 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2522 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2527 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2530 parse_threadlist_response (char *pkt
, int result_limit
,
2531 threadref
*original_echo
, threadref
*resultlist
,
2534 struct remote_state
*rs
= get_remote_state ();
2536 int count
, resultcount
, done
;
2539 /* Assume the 'q' and 'M chars have been stripped. */
2540 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2541 /* done parse past here */
2542 pkt
= unpack_byte (pkt
, &count
); /* count field */
2543 pkt
= unpack_nibble (pkt
, &done
);
2544 /* The first threadid is the argument threadid. */
2545 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2546 while ((count
-- > 0) && (pkt
< limit
))
2548 pkt
= unpack_threadid (pkt
, resultlist
++);
2549 if (resultcount
++ >= result_limit
)
2557 /* Fetch the next batch of threads from the remote. Returns -1 if the
2558 qL packet is not supported, 0 on error and 1 on success. */
2561 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2562 int *done
, int *result_count
, threadref
*threadlist
)
2564 struct remote_state
*rs
= get_remote_state ();
2567 /* Trancate result limit to be smaller than the packet size. */
2568 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
2569 >= get_remote_packet_size ())
2570 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2572 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2574 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2575 if (*rs
->buf
== '\0')
2577 /* Packet not supported. */
2582 parse_threadlist_response (rs
->buf
+ 2, result_limit
,
2583 &rs
->echo_nextthread
, threadlist
, done
);
2585 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
2587 /* FIXME: This is a good reason to drop the packet. */
2588 /* Possably, there is a duplicate response. */
2590 retransmit immediatly - race conditions
2591 retransmit after timeout - yes
2593 wait for packet, then exit
2595 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2596 return 0; /* I choose simply exiting. */
2598 if (*result_count
<= 0)
2602 warning (_("RMT ERROR : failed to get remote thread list."));
2605 return result
; /* break; */
2607 if (*result_count
> result_limit
)
2610 warning (_("RMT ERROR: threadlist response longer than requested."));
2616 /* Fetch the list of remote threads, with the qL packet, and call
2617 STEPFUNCTION for each thread found. Stops iterating and returns 1
2618 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2619 STEPFUNCTION returns false. If the packet is not supported,
2623 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2626 struct remote_state
*rs
= get_remote_state ();
2627 int done
, i
, result_count
;
2635 if (loopcount
++ > looplimit
)
2638 warning (_("Remote fetch threadlist -infinite loop-."));
2641 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
2642 MAXTHREADLISTRESULTS
,
2643 &done
, &result_count
,
2644 rs
->resultthreadlist
);
2647 /* Clear for later iterations. */
2649 /* Setup to resume next batch of thread references, set nextthread. */
2650 if (result_count
>= 1)
2651 copy_threadref (&rs
->nextthread
,
2652 &rs
->resultthreadlist
[result_count
- 1]);
2654 while (result_count
--)
2656 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
2666 /* A thread found on the remote target. */
2668 typedef struct thread_item
2670 /* The thread's PTID. */
2673 /* The thread's extra info. May be NULL. */
2676 /* The core the thread was running on. -1 if not known. */
2679 DEF_VEC_O(thread_item_t
);
2681 /* Context passed around to the various methods listing remote
2682 threads. As new threads are found, they're added to the ITEMS
2685 struct threads_listing_context
2687 /* The threads found on the remote target. */
2688 VEC (thread_item_t
) *items
;
2691 /* Discard the contents of the constructed thread listing context. */
2694 clear_threads_listing_context (void *p
)
2696 struct threads_listing_context
*context
= p
;
2698 struct thread_item
*item
;
2700 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
2701 xfree (item
->extra
);
2703 VEC_free (thread_item_t
, context
->items
);
2706 /* Remove the thread specified as the related_pid field of WS
2707 from the CONTEXT list. */
2710 threads_listing_context_remove (struct target_waitstatus
*ws
,
2711 struct threads_listing_context
*context
)
2713 struct thread_item
*item
;
2715 ptid_t child_ptid
= ws
->value
.related_pid
;
2717 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
2719 if (ptid_equal (item
->ptid
, child_ptid
))
2721 VEC_ordered_remove (thread_item_t
, context
->items
, i
);
2728 remote_newthread_step (threadref
*ref
, void *data
)
2730 struct threads_listing_context
*context
= data
;
2731 struct thread_item item
;
2732 int pid
= ptid_get_pid (inferior_ptid
);
2734 item
.ptid
= ptid_build (pid
, threadref_to_int (ref
), 0);
2738 VEC_safe_push (thread_item_t
, context
->items
, &item
);
2740 return 1; /* continue iterator */
2743 #define CRAZY_MAX_THREADS 1000
2746 remote_current_thread (ptid_t oldpid
)
2748 struct remote_state
*rs
= get_remote_state ();
2751 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2752 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
2753 return read_ptid (&rs
->buf
[2], NULL
);
2758 /* List remote threads using the deprecated qL packet. */
2761 remote_get_threads_with_ql (struct target_ops
*ops
,
2762 struct threads_listing_context
*context
)
2764 if (remote_threadlist_iterator (remote_newthread_step
, context
,
2765 CRAZY_MAX_THREADS
) >= 0)
2771 #if defined(HAVE_LIBEXPAT)
2774 start_thread (struct gdb_xml_parser
*parser
,
2775 const struct gdb_xml_element
*element
,
2776 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
2778 struct threads_listing_context
*data
= user_data
;
2780 struct thread_item item
;
2782 struct gdb_xml_value
*attr
;
2784 id
= xml_find_attribute (attributes
, "id")->value
;
2785 item
.ptid
= read_ptid (id
, NULL
);
2787 attr
= xml_find_attribute (attributes
, "core");
2789 item
.core
= *(ULONGEST
*) attr
->value
;
2795 VEC_safe_push (thread_item_t
, data
->items
, &item
);
2799 end_thread (struct gdb_xml_parser
*parser
,
2800 const struct gdb_xml_element
*element
,
2801 void *user_data
, const char *body_text
)
2803 struct threads_listing_context
*data
= user_data
;
2805 if (body_text
&& *body_text
)
2806 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
2809 const struct gdb_xml_attribute thread_attributes
[] = {
2810 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
2811 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2812 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2815 const struct gdb_xml_element thread_children
[] = {
2816 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2819 const struct gdb_xml_element threads_children
[] = {
2820 { "thread", thread_attributes
, thread_children
,
2821 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
2822 start_thread
, end_thread
},
2823 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2826 const struct gdb_xml_element threads_elements
[] = {
2827 { "threads", NULL
, threads_children
,
2828 GDB_XML_EF_NONE
, NULL
, NULL
},
2829 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2834 /* List remote threads using qXfer:threads:read. */
2837 remote_get_threads_with_qxfer (struct target_ops
*ops
,
2838 struct threads_listing_context
*context
)
2840 #if defined(HAVE_LIBEXPAT)
2841 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
2843 char *xml
= target_read_stralloc (ops
, TARGET_OBJECT_THREADS
, NULL
);
2844 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
2846 if (xml
!= NULL
&& *xml
!= '\0')
2848 gdb_xml_parse_quick (_("threads"), "threads.dtd",
2849 threads_elements
, xml
, context
);
2852 do_cleanups (back_to
);
2860 /* List remote threads using qfThreadInfo/qsThreadInfo. */
2863 remote_get_threads_with_qthreadinfo (struct target_ops
*ops
,
2864 struct threads_listing_context
*context
)
2866 struct remote_state
*rs
= get_remote_state ();
2868 if (rs
->use_threadinfo_query
)
2872 putpkt ("qfThreadInfo");
2873 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2875 if (bufp
[0] != '\0') /* q packet recognized */
2877 while (*bufp
++ == 'm') /* reply contains one or more TID */
2881 struct thread_item item
;
2883 item
.ptid
= read_ptid (bufp
, &bufp
);
2887 VEC_safe_push (thread_item_t
, context
->items
, &item
);
2889 while (*bufp
++ == ','); /* comma-separated list */
2890 putpkt ("qsThreadInfo");
2891 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2898 /* Packet not recognized. */
2899 rs
->use_threadinfo_query
= 0;
2906 /* Implement the to_update_thread_list function for the remote
2910 remote_update_thread_list (struct target_ops
*ops
)
2912 struct remote_state
*rs
= get_remote_state ();
2913 struct threads_listing_context context
;
2914 struct cleanup
*old_chain
;
2917 context
.items
= NULL
;
2918 old_chain
= make_cleanup (clear_threads_listing_context
, &context
);
2920 /* We have a few different mechanisms to fetch the thread list. Try
2921 them all, starting with the most preferred one first, falling
2922 back to older methods. */
2923 if (remote_get_threads_with_qxfer (ops
, &context
)
2924 || remote_get_threads_with_qthreadinfo (ops
, &context
)
2925 || remote_get_threads_with_ql (ops
, &context
))
2928 struct thread_item
*item
;
2929 struct thread_info
*tp
, *tmp
;
2933 if (VEC_empty (thread_item_t
, context
.items
)
2934 && remote_thread_always_alive (ops
, inferior_ptid
))
2936 /* Some targets don't really support threads, but still
2937 reply an (empty) thread list in response to the thread
2938 listing packets, instead of replying "packet not
2939 supported". Exit early so we don't delete the main
2941 do_cleanups (old_chain
);
2945 /* CONTEXT now holds the current thread list on the remote
2946 target end. Delete GDB-side threads no longer found on the
2948 ALL_THREADS_SAFE (tp
, tmp
)
2951 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
2954 if (ptid_equal (item
->ptid
, tp
->ptid
))
2958 if (i
== VEC_length (thread_item_t
, context
.items
))
2961 delete_thread (tp
->ptid
);
2965 /* Remove any unreported fork child threads from CONTEXT so
2966 that we don't interfere with follow fork, which is where
2967 creation of such threads is handled. */
2968 remove_new_fork_children (&context
);
2970 /* And now add threads we don't know about yet to our list. */
2972 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
2975 if (!ptid_equal (item
->ptid
, null_ptid
))
2977 struct private_thread_info
*info
;
2978 /* In non-stop mode, we assume new found threads are
2979 running until proven otherwise with a stop reply. In
2980 all-stop, we can only get here if all threads are
2982 int running
= non_stop
? 1 : 0;
2984 remote_notice_new_inferior (item
->ptid
, running
);
2986 info
= demand_private_info (item
->ptid
);
2987 info
->core
= item
->core
;
2988 info
->extra
= item
->extra
;
2996 /* If no thread listing method is supported, then query whether
2997 each known thread is alive, one by one, with the T packet.
2998 If the target doesn't support threads at all, then this is a
2999 no-op. See remote_thread_alive. */
3003 do_cleanups (old_chain
);
3007 * Collect a descriptive string about the given thread.
3008 * The target may say anything it wants to about the thread
3009 * (typically info about its blocked / runnable state, name, etc.).
3010 * This string will appear in the info threads display.
3012 * Optional: targets are not required to implement this function.
3016 remote_threads_extra_info (struct target_ops
*self
, struct thread_info
*tp
)
3018 struct remote_state
*rs
= get_remote_state ();
3022 struct gdb_ext_thread_info threadinfo
;
3023 static char display_buf
[100]; /* arbitrary... */
3024 int n
= 0; /* position in display_buf */
3026 if (rs
->remote_desc
== 0) /* paranoia */
3027 internal_error (__FILE__
, __LINE__
,
3028 _("remote_threads_extra_info"));
3030 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
3031 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_lwp (tp
->ptid
) == 0))
3032 /* This is the main thread which was added by GDB. The remote
3033 server doesn't know about it. */
3036 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3038 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
3040 if (info
&& info
->priv
)
3041 return info
->priv
->extra
;
3046 if (rs
->use_threadextra_query
)
3049 char *endb
= rs
->buf
+ get_remote_packet_size ();
3051 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3053 write_ptid (b
, endb
, tp
->ptid
);
3056 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3057 if (rs
->buf
[0] != 0)
3059 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
3060 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
3061 display_buf
[result
] = '\0';
3066 /* If the above query fails, fall back to the old method. */
3067 rs
->use_threadextra_query
= 0;
3068 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3069 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3070 int_to_threadref (&id
, ptid_get_lwp (tp
->ptid
));
3071 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3072 if (threadinfo
.active
)
3074 if (*threadinfo
.shortname
)
3075 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
3076 " Name: %s,", threadinfo
.shortname
);
3077 if (*threadinfo
.display
)
3078 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3079 " State: %s,", threadinfo
.display
);
3080 if (*threadinfo
.more_display
)
3081 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3082 " Priority: %s", threadinfo
.more_display
);
3086 /* For purely cosmetic reasons, clear up trailing commas. */
3087 if (',' == display_buf
[n
-1])
3088 display_buf
[n
-1] = ' ';
3097 remote_static_tracepoint_marker_at (struct target_ops
*self
, CORE_ADDR addr
,
3098 struct static_tracepoint_marker
*marker
)
3100 struct remote_state
*rs
= get_remote_state ();
3103 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3105 p
+= hexnumstr (p
, addr
);
3107 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3111 error (_("Remote failure reply: %s"), p
);
3115 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3122 static VEC(static_tracepoint_marker_p
) *
3123 remote_static_tracepoint_markers_by_strid (struct target_ops
*self
,
3126 struct remote_state
*rs
= get_remote_state ();
3127 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
3128 struct static_tracepoint_marker
*marker
= NULL
;
3129 struct cleanup
*old_chain
;
3132 /* Ask for a first packet of static tracepoint marker
3135 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3138 error (_("Remote failure reply: %s"), p
);
3140 old_chain
= make_cleanup (free_current_marker
, &marker
);
3145 marker
= XCNEW (struct static_tracepoint_marker
);
3149 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3151 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
3153 VEC_safe_push (static_tracepoint_marker_p
,
3159 release_static_tracepoint_marker (marker
);
3160 memset (marker
, 0, sizeof (*marker
));
3163 while (*p
++ == ','); /* comma-separated list */
3164 /* Ask for another packet of static tracepoint definition. */
3166 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3170 do_cleanups (old_chain
);
3175 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3178 remote_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
3180 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
3184 /* Restart the remote side; this is an extended protocol operation. */
3187 extended_remote_restart (void)
3189 struct remote_state
*rs
= get_remote_state ();
3191 /* Send the restart command; for reasons I don't understand the
3192 remote side really expects a number after the "R". */
3193 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
3196 remote_fileio_reset ();
3199 /* Clean up connection to a remote debugger. */
3202 remote_close (struct target_ops
*self
)
3204 struct remote_state
*rs
= get_remote_state ();
3206 if (rs
->remote_desc
== NULL
)
3207 return; /* already closed */
3209 /* Make sure we leave stdin registered in the event loop, and we
3210 don't leave the async SIGINT signal handler installed. */
3211 remote_terminal_ours (self
);
3213 serial_close (rs
->remote_desc
);
3214 rs
->remote_desc
= NULL
;
3216 /* We don't have a connection to the remote stub anymore. Get rid
3217 of all the inferiors and their threads we were controlling.
3218 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3219 will be unable to find the thread corresponding to (pid, 0, 0). */
3220 inferior_ptid
= null_ptid
;
3221 discard_all_inferiors ();
3223 /* We are closing the remote target, so we should discard
3224 everything of this target. */
3225 discard_pending_stop_replies_in_queue (rs
);
3227 if (remote_async_inferior_event_token
)
3228 delete_async_event_handler (&remote_async_inferior_event_token
);
3230 remote_notif_state_xfree (rs
->notif_state
);
3232 trace_reset_local_state ();
3235 /* Query the remote side for the text, data and bss offsets. */
3240 struct remote_state
*rs
= get_remote_state ();
3243 int lose
, num_segments
= 0, do_sections
, do_segments
;
3244 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
3245 struct section_offsets
*offs
;
3246 struct symfile_segment_data
*data
;
3248 if (symfile_objfile
== NULL
)
3251 putpkt ("qOffsets");
3252 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3255 if (buf
[0] == '\000')
3256 return; /* Return silently. Stub doesn't support
3260 warning (_("Remote failure reply: %s"), buf
);
3264 /* Pick up each field in turn. This used to be done with scanf, but
3265 scanf will make trouble if CORE_ADDR size doesn't match
3266 conversion directives correctly. The following code will work
3267 with any size of CORE_ADDR. */
3268 text_addr
= data_addr
= bss_addr
= 0;
3272 if (startswith (ptr
, "Text="))
3275 /* Don't use strtol, could lose on big values. */
3276 while (*ptr
&& *ptr
!= ';')
3277 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3279 if (startswith (ptr
, ";Data="))
3282 while (*ptr
&& *ptr
!= ';')
3283 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3288 if (!lose
&& startswith (ptr
, ";Bss="))
3291 while (*ptr
&& *ptr
!= ';')
3292 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
3294 if (bss_addr
!= data_addr
)
3295 warning (_("Target reported unsupported offsets: %s"), buf
);
3300 else if (startswith (ptr
, "TextSeg="))
3303 /* Don't use strtol, could lose on big values. */
3304 while (*ptr
&& *ptr
!= ';')
3305 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3308 if (startswith (ptr
, ";DataSeg="))
3311 while (*ptr
&& *ptr
!= ';')
3312 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3320 error (_("Malformed response to offset query, %s"), buf
);
3321 else if (*ptr
!= '\0')
3322 warning (_("Target reported unsupported offsets: %s"), buf
);
3324 offs
= ((struct section_offsets
*)
3325 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
3326 memcpy (offs
, symfile_objfile
->section_offsets
,
3327 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
3329 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
3330 do_segments
= (data
!= NULL
);
3331 do_sections
= num_segments
== 0;
3333 if (num_segments
> 0)
3335 segments
[0] = text_addr
;
3336 segments
[1] = data_addr
;
3338 /* If we have two segments, we can still try to relocate everything
3339 by assuming that the .text and .data offsets apply to the whole
3340 text and data segments. Convert the offsets given in the packet
3341 to base addresses for symfile_map_offsets_to_segments. */
3342 else if (data
&& data
->num_segments
== 2)
3344 segments
[0] = data
->segment_bases
[0] + text_addr
;
3345 segments
[1] = data
->segment_bases
[1] + data_addr
;
3348 /* If the object file has only one segment, assume that it is text
3349 rather than data; main programs with no writable data are rare,
3350 but programs with no code are useless. Of course the code might
3351 have ended up in the data segment... to detect that we would need
3352 the permissions here. */
3353 else if (data
&& data
->num_segments
== 1)
3355 segments
[0] = data
->segment_bases
[0] + text_addr
;
3358 /* There's no way to relocate by segment. */
3364 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
3365 offs
, num_segments
, segments
);
3367 if (ret
== 0 && !do_sections
)
3368 error (_("Can not handle qOffsets TextSeg "
3369 "response with this symbol file"));
3376 free_symfile_segment_data (data
);
3380 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
3382 /* This is a temporary kludge to force data and bss to use the
3383 same offsets because that's what nlmconv does now. The real
3384 solution requires changes to the stub and remote.c that I
3385 don't have time to do right now. */
3387 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
3388 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
3391 objfile_relocate (symfile_objfile
, offs
);
3394 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in
3395 threads we know are stopped already. This is used during the
3396 initial remote connection in non-stop mode --- threads that are
3397 reported as already being stopped are left stopped. */
3400 set_stop_requested_callback (struct thread_info
*thread
, void *data
)
3402 /* If we have a stop reply for this thread, it must be stopped. */
3403 if (peek_stop_reply (thread
->ptid
))
3404 set_stop_requested (thread
->ptid
, 1);
3409 /* Send interrupt_sequence to remote target. */
3411 send_interrupt_sequence (void)
3413 struct remote_state
*rs
= get_remote_state ();
3415 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
3416 remote_serial_write ("\x03", 1);
3417 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
3418 serial_send_break (rs
->remote_desc
);
3419 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
3421 serial_send_break (rs
->remote_desc
);
3422 remote_serial_write ("g", 1);
3425 internal_error (__FILE__
, __LINE__
,
3426 _("Invalid value for interrupt_sequence_mode: %s."),
3427 interrupt_sequence_mode
);
3431 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3432 and extract the PTID. Returns NULL_PTID if not found. */
3435 stop_reply_extract_thread (char *stop_reply
)
3437 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
3441 /* Txx r:val ; r:val (...) */
3444 /* Look for "register" named "thread". */
3449 p1
= strchr (p
, ':');
3453 if (strncmp (p
, "thread", p1
- p
) == 0)
3454 return read_ptid (++p1
, &p
);
3456 p1
= strchr (p
, ';');
3468 /* Determine the remote side's current thread. If we have a stop
3469 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3470 "thread" register we can extract the current thread from. If not,
3471 ask the remote which is the current thread with qC. The former
3472 method avoids a roundtrip. */
3475 get_current_thread (char *wait_status
)
3477 ptid_t ptid
= null_ptid
;
3479 /* Note we don't use remote_parse_stop_reply as that makes use of
3480 the target architecture, which we haven't yet fully determined at
3482 if (wait_status
!= NULL
)
3483 ptid
= stop_reply_extract_thread (wait_status
);
3484 if (ptid_equal (ptid
, null_ptid
))
3485 ptid
= remote_current_thread (inferior_ptid
);
3490 /* Query the remote target for which is the current thread/process,
3491 add it to our tables, and update INFERIOR_PTID. The caller is
3492 responsible for setting the state such that the remote end is ready
3493 to return the current thread.
3495 This function is called after handling the '?' or 'vRun' packets,
3496 whose response is a stop reply from which we can also try
3497 extracting the thread. If the target doesn't support the explicit
3498 qC query, we infer the current thread from that stop reply, passed
3499 in in WAIT_STATUS, which may be NULL. */
3502 add_current_inferior_and_thread (char *wait_status
)
3504 struct remote_state
*rs
= get_remote_state ();
3508 inferior_ptid
= null_ptid
;
3510 /* Now, if we have thread information, update inferior_ptid. */
3511 ptid
= get_current_thread (wait_status
);
3513 if (!ptid_equal (ptid
, null_ptid
))
3515 if (!remote_multi_process_p (rs
))
3518 inferior_ptid
= ptid
;
3522 /* Without this, some commands which require an active target
3523 (such as kill) won't work. This variable serves (at least)
3524 double duty as both the pid of the target process (if it has
3525 such), and as a flag indicating that a target is active. */
3526 inferior_ptid
= magic_null_ptid
;
3530 remote_add_inferior (fake_pid_p
, ptid_get_pid (inferior_ptid
), -1, 1);
3532 /* Add the main thread. */
3533 add_thread_silent (inferior_ptid
);
3537 remote_start_remote (int from_tty
, struct target_ops
*target
, int extended_p
)
3539 struct remote_state
*rs
= get_remote_state ();
3540 struct packet_config
*noack_config
;
3541 char *wait_status
= NULL
;
3543 immediate_quit
++; /* Allow user to interrupt it. */
3546 if (interrupt_on_connect
)
3547 send_interrupt_sequence ();
3549 /* Ack any packet which the remote side has already sent. */
3550 serial_write (rs
->remote_desc
, "+", 1);
3552 /* Signal other parts that we're going through the initial setup,
3553 and so things may not be stable yet. */
3554 rs
->starting_up
= 1;
3556 /* The first packet we send to the target is the optional "supported
3557 packets" request. If the target can answer this, it will tell us
3558 which later probes to skip. */
3559 remote_query_supported ();
3561 /* If the stub wants to get a QAllow, compose one and send it. */
3562 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
3563 remote_set_permissions (target
);
3565 /* Next, we possibly activate noack mode.
3567 If the QStartNoAckMode packet configuration is set to AUTO,
3568 enable noack mode if the stub reported a wish for it with
3571 If set to TRUE, then enable noack mode even if the stub didn't
3572 report it in qSupported. If the stub doesn't reply OK, the
3573 session ends with an error.
3575 If FALSE, then don't activate noack mode, regardless of what the
3576 stub claimed should be the default with qSupported. */
3578 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
3579 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
3581 putpkt ("QStartNoAckMode");
3582 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3583 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
3589 /* Tell the remote that we are using the extended protocol. */
3591 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3594 /* Let the target know which signals it is allowed to pass down to
3596 update_signals_program_target ();
3598 /* Next, if the target can specify a description, read it. We do
3599 this before anything involving memory or registers. */
3600 target_find_description ();
3602 /* Next, now that we know something about the target, update the
3603 address spaces in the program spaces. */
3604 update_address_spaces ();
3606 /* On OSs where the list of libraries is global to all
3607 processes, we fetch them early. */
3608 if (gdbarch_has_global_solist (target_gdbarch ()))
3609 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
3613 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
3614 error (_("Non-stop mode requested, but remote "
3615 "does not support non-stop"));
3617 putpkt ("QNonStop:1");
3618 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3620 if (strcmp (rs
->buf
, "OK") != 0)
3621 error (_("Remote refused setting non-stop mode with: %s"), rs
->buf
);
3623 /* Find about threads and processes the stub is already
3624 controlling. We default to adding them in the running state.
3625 The '?' query below will then tell us about which threads are
3627 remote_update_thread_list (target
);
3629 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
3631 /* Don't assume that the stub can operate in all-stop mode.
3632 Request it explicitly. */
3633 putpkt ("QNonStop:0");
3634 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3636 if (strcmp (rs
->buf
, "OK") != 0)
3637 error (_("Remote refused setting all-stop mode with: %s"), rs
->buf
);
3640 /* Upload TSVs regardless of whether the target is running or not. The
3641 remote stub, such as GDBserver, may have some predefined or builtin
3642 TSVs, even if the target is not running. */
3643 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
3645 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3647 remote_upload_trace_state_variables (target
, &uploaded_tsvs
);
3648 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3651 /* Check whether the target is running now. */
3653 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3659 struct inferior
*inf
;
3661 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
3664 error (_("The target is not running (try extended-remote?)"));
3666 /* We're connected, but not running. Drop out before we
3667 call start_remote. */
3668 rs
->starting_up
= 0;
3673 /* Save the reply for later. */
3674 wait_status
= alloca (strlen (rs
->buf
) + 1);
3675 strcpy (wait_status
, rs
->buf
);
3678 /* Fetch thread list. */
3679 target_update_thread_list ();
3681 /* Let the stub know that we want it to return the thread. */
3682 set_continue_thread (minus_one_ptid
);
3684 if (thread_count () == 0)
3686 /* Target has no concept of threads at all. GDB treats
3687 non-threaded target as single-threaded; add a main
3689 add_current_inferior_and_thread (wait_status
);
3693 /* We have thread information; select the thread the target
3694 says should be current. If we're reconnecting to a
3695 multi-threaded program, this will ideally be the thread
3696 that last reported an event before GDB disconnected. */
3697 inferior_ptid
= get_current_thread (wait_status
);
3698 if (ptid_equal (inferior_ptid
, null_ptid
))
3700 /* Odd... The target was able to list threads, but not
3701 tell us which thread was current (no "thread"
3702 register in T stop reply?). Just pick the first
3703 thread in the thread list then. */
3704 inferior_ptid
= thread_list
->ptid
;
3708 /* init_wait_for_inferior should be called before get_offsets in order
3709 to manage `inserted' flag in bp loc in a correct state.
3710 breakpoint_init_inferior, called from init_wait_for_inferior, set
3711 `inserted' flag to 0, while before breakpoint_re_set, called from
3712 start_remote, set `inserted' flag to 1. In the initialization of
3713 inferior, breakpoint_init_inferior should be called first, and then
3714 breakpoint_re_set can be called. If this order is broken, state of
3715 `inserted' flag is wrong, and cause some problems on breakpoint
3717 init_wait_for_inferior ();
3719 get_offsets (); /* Get text, data & bss offsets. */
3721 /* If we could not find a description using qXfer, and we know
3722 how to do it some other way, try again. This is not
3723 supported for non-stop; it could be, but it is tricky if
3724 there are no stopped threads when we connect. */
3725 if (remote_read_description_p (target
)
3726 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
3728 target_clear_description ();
3729 target_find_description ();
3732 /* Use the previously fetched status. */
3733 gdb_assert (wait_status
!= NULL
);
3734 strcpy (rs
->buf
, wait_status
);
3735 rs
->cached_wait_status
= 1;
3738 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
3742 /* Clear WFI global state. Do this before finding about new
3743 threads and inferiors, and setting the current inferior.
3744 Otherwise we would clear the proceed status of the current
3745 inferior when we want its stop_soon state to be preserved
3746 (see notice_new_inferior). */
3747 init_wait_for_inferior ();
3749 /* In non-stop, we will either get an "OK", meaning that there
3750 are no stopped threads at this time; or, a regular stop
3751 reply. In the latter case, there may be more than one thread
3752 stopped --- we pull them all out using the vStopped
3754 if (strcmp (rs
->buf
, "OK") != 0)
3756 struct notif_client
*notif
= ¬if_client_stop
;
3758 /* remote_notif_get_pending_replies acks this one, and gets
3760 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
3761 = remote_notif_parse (notif
, rs
->buf
);
3762 remote_notif_get_pending_events (notif
);
3764 /* Make sure that threads that were stopped remain
3766 iterate_over_threads (set_stop_requested_callback
, NULL
);
3769 if (target_can_async_p ())
3772 if (thread_count () == 0)
3775 error (_("The target is not running (try extended-remote?)"));
3777 /* We're connected, but not running. Drop out before we
3778 call start_remote. */
3779 rs
->starting_up
= 0;
3783 /* Let the stub know that we want it to return the thread. */
3785 /* Force the stub to choose a thread. */
3786 set_general_thread (null_ptid
);
3789 inferior_ptid
= remote_current_thread (minus_one_ptid
);
3790 if (ptid_equal (inferior_ptid
, minus_one_ptid
))
3791 error (_("remote didn't report the current thread in non-stop mode"));
3793 get_offsets (); /* Get text, data & bss offsets. */
3795 /* In non-stop mode, any cached wait status will be stored in
3796 the stop reply queue. */
3797 gdb_assert (wait_status
== NULL
);
3799 /* Report all signals during attach/startup. */
3800 remote_pass_signals (target
, 0, NULL
);
3803 /* If we connected to a live target, do some additional setup. */
3804 if (target_has_execution
)
3806 if (symfile_objfile
) /* No use without a symbol-file. */
3807 remote_check_symbols ();
3810 /* Possibly the target has been engaged in a trace run started
3811 previously; find out where things are at. */
3812 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
3814 struct uploaded_tp
*uploaded_tps
= NULL
;
3816 if (current_trace_status ()->running
)
3817 printf_filtered (_("Trace is already running on the target.\n"));
3819 remote_upload_tracepoints (target
, &uploaded_tps
);
3821 merge_uploaded_tracepoints (&uploaded_tps
);
3824 /* The thread and inferior lists are now synchronized with the
3825 target, our symbols have been relocated, and we're merged the
3826 target's tracepoints with ours. We're done with basic start
3828 rs
->starting_up
= 0;
3830 /* Maybe breakpoints are global and need to be inserted now. */
3831 if (breakpoints_should_be_inserted_now ())
3832 insert_breakpoints ();
3835 /* Open a connection to a remote debugger.
3836 NAME is the filename used for communication. */
3839 remote_open (const char *name
, int from_tty
)
3841 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
3844 /* Open a connection to a remote debugger using the extended
3845 remote gdb protocol. NAME is the filename used for communication. */
3848 extended_remote_open (const char *name
, int from_tty
)
3850 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
3853 /* Reset all packets back to "unknown support". Called when opening a
3854 new connection to a remote target. */
3857 reset_all_packet_configs_support (void)
3861 for (i
= 0; i
< PACKET_MAX
; i
++)
3862 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
3865 /* Initialize all packet configs. */
3868 init_all_packet_configs (void)
3872 for (i
= 0; i
< PACKET_MAX
; i
++)
3874 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
3875 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
3879 /* Symbol look-up. */
3882 remote_check_symbols (void)
3884 struct remote_state
*rs
= get_remote_state ();
3885 char *msg
, *reply
, *tmp
;
3886 struct bound_minimal_symbol sym
;
3889 /* The remote side has no concept of inferiors that aren't running
3890 yet, it only knows about running processes. If we're connected
3891 but our current inferior is not running, we should not invite the
3892 remote target to request symbol lookups related to its
3893 (unrelated) current process. */
3894 if (!target_has_execution
)
3897 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
3900 /* Make sure the remote is pointing at the right process. Note
3901 there's no way to select "no process". */
3902 set_general_process ();
3904 /* Allocate a message buffer. We can't reuse the input buffer in RS,
3905 because we need both at the same time. */
3906 msg
= alloca (get_remote_packet_size ());
3908 /* Invite target to request symbol lookups. */
3910 putpkt ("qSymbol::");
3911 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3912 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
3915 while (startswith (reply
, "qSymbol:"))
3917 struct bound_minimal_symbol sym
;
3920 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
3922 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
3923 if (sym
.minsym
== NULL
)
3924 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
3927 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
3928 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
3930 /* If this is a function address, return the start of code
3931 instead of any data function descriptor. */
3932 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
3936 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
3937 phex_nz (sym_addr
, addr_size
), &reply
[8]);
3941 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3946 static struct serial
*
3947 remote_serial_open (const char *name
)
3949 static int udp_warning
= 0;
3951 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
3952 of in ser-tcp.c, because it is the remote protocol assuming that the
3953 serial connection is reliable and not the serial connection promising
3955 if (!udp_warning
&& startswith (name
, "udp:"))
3957 warning (_("The remote protocol may be unreliable over UDP.\n"
3958 "Some events may be lost, rendering further debugging "
3963 return serial_open (name
);
3966 /* Inform the target of our permission settings. The permission flags
3967 work without this, but if the target knows the settings, it can do
3968 a couple things. First, it can add its own check, to catch cases
3969 that somehow manage to get by the permissions checks in target
3970 methods. Second, if the target is wired to disallow particular
3971 settings (for instance, a system in the field that is not set up to
3972 be able to stop at a breakpoint), it can object to any unavailable
3976 remote_set_permissions (struct target_ops
*self
)
3978 struct remote_state
*rs
= get_remote_state ();
3980 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAllow:"
3981 "WriteReg:%x;WriteMem:%x;"
3982 "InsertBreak:%x;InsertTrace:%x;"
3983 "InsertFastTrace:%x;Stop:%x",
3984 may_write_registers
, may_write_memory
,
3985 may_insert_breakpoints
, may_insert_tracepoints
,
3986 may_insert_fast_tracepoints
, may_stop
);
3988 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3990 /* If the target didn't like the packet, warn the user. Do not try
3991 to undo the user's settings, that would just be maddening. */
3992 if (strcmp (rs
->buf
, "OK") != 0)
3993 warning (_("Remote refused setting permissions with: %s"), rs
->buf
);
3996 /* This type describes each known response to the qSupported
3998 struct protocol_feature
4000 /* The name of this protocol feature. */
4003 /* The default for this protocol feature. */
4004 enum packet_support default_support
;
4006 /* The function to call when this feature is reported, or after
4007 qSupported processing if the feature is not supported.
4008 The first argument points to this structure. The second
4009 argument indicates whether the packet requested support be
4010 enabled, disabled, or probed (or the default, if this function
4011 is being called at the end of processing and this feature was
4012 not reported). The third argument may be NULL; if not NULL, it
4013 is a NUL-terminated string taken from the packet following
4014 this feature's name and an equals sign. */
4015 void (*func
) (const struct protocol_feature
*, enum packet_support
,
4018 /* The corresponding packet for this feature. Only used if
4019 FUNC is remote_supported_packet. */
4024 remote_supported_packet (const struct protocol_feature
*feature
,
4025 enum packet_support support
,
4026 const char *argument
)
4030 warning (_("Remote qSupported response supplied an unexpected value for"
4031 " \"%s\"."), feature
->name
);
4035 remote_protocol_packets
[feature
->packet
].support
= support
;
4039 remote_packet_size (const struct protocol_feature
*feature
,
4040 enum packet_support support
, const char *value
)
4042 struct remote_state
*rs
= get_remote_state ();
4047 if (support
!= PACKET_ENABLE
)
4050 if (value
== NULL
|| *value
== '\0')
4052 warning (_("Remote target reported \"%s\" without a size."),
4058 packet_size
= strtol (value
, &value_end
, 16);
4059 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
4061 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4062 feature
->name
, value
);
4066 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
4068 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
4069 packet_size
, MAX_REMOTE_PACKET_SIZE
);
4070 packet_size
= MAX_REMOTE_PACKET_SIZE
;
4073 /* Record the new maximum packet size. */
4074 rs
->explicit_packet_size
= packet_size
;
4077 static const struct protocol_feature remote_protocol_features
[] = {
4078 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
4079 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
4080 PACKET_qXfer_auxv
},
4081 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
4082 PACKET_qXfer_exec_file
},
4083 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
4084 PACKET_qXfer_features
},
4085 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
4086 PACKET_qXfer_libraries
},
4087 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
4088 PACKET_qXfer_libraries_svr4
},
4089 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
4090 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
4091 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
4092 PACKET_qXfer_memory_map
},
4093 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
4094 PACKET_qXfer_spu_read
},
4095 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
4096 PACKET_qXfer_spu_write
},
4097 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
4098 PACKET_qXfer_osdata
},
4099 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
4100 PACKET_qXfer_threads
},
4101 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
4102 PACKET_qXfer_traceframe_info
},
4103 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
4104 PACKET_QPassSignals
},
4105 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
4106 PACKET_QProgramSignals
},
4107 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
4108 PACKET_QStartNoAckMode
},
4109 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
4110 PACKET_multiprocess_feature
},
4111 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
4112 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
4113 PACKET_qXfer_siginfo_read
},
4114 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
4115 PACKET_qXfer_siginfo_write
},
4116 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4117 PACKET_ConditionalTracepoints
},
4118 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
4119 PACKET_ConditionalBreakpoints
},
4120 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
4121 PACKET_BreakpointCommands
},
4122 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4123 PACKET_FastTracepoints
},
4124 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4125 PACKET_StaticTracepoints
},
4126 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
4127 PACKET_InstallInTrace
},
4128 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
4129 PACKET_DisconnectedTracing_feature
},
4130 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
4132 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
4134 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
4135 PACKET_TracepointSource
},
4136 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
4138 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4139 PACKET_EnableDisableTracepoints_feature
},
4140 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
4141 PACKET_qXfer_fdpic
},
4142 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
4144 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
4145 PACKET_QDisableRandomization
},
4146 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
4147 { "QTBuffer:size", PACKET_DISABLE
,
4148 remote_supported_packet
, PACKET_QTBuffer_size
},
4149 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
4150 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
4151 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
4152 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
4153 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
4154 PACKET_qXfer_btrace
},
4155 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
4156 PACKET_qXfer_btrace_conf
},
4157 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
4158 PACKET_Qbtrace_conf_bts_size
},
4159 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
4160 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
4161 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
4162 PACKET_fork_event_feature
},
4163 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
4164 PACKET_vfork_event_feature
},
4165 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
4166 PACKET_Qbtrace_conf_pt_size
}
4169 static char *remote_support_xml
;
4171 /* Register string appended to "xmlRegisters=" in qSupported query. */
4174 register_remote_support_xml (const char *xml
)
4176 #if defined(HAVE_LIBEXPAT)
4177 if (remote_support_xml
== NULL
)
4178 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
4181 char *copy
= xstrdup (remote_support_xml
+ 13);
4182 char *p
= strtok (copy
, ",");
4186 if (strcmp (p
, xml
) == 0)
4193 while ((p
= strtok (NULL
, ",")) != NULL
);
4196 remote_support_xml
= reconcat (remote_support_xml
,
4197 remote_support_xml
, ",", xml
,
4204 remote_query_supported_append (char *msg
, const char *append
)
4207 return reconcat (msg
, msg
, ";", append
, (char *) NULL
);
4209 return xstrdup (append
);
4213 remote_query_supported (void)
4215 struct remote_state
*rs
= get_remote_state ();
4218 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
4220 /* The packet support flags are handled differently for this packet
4221 than for most others. We treat an error, a disabled packet, and
4222 an empty response identically: any features which must be reported
4223 to be used will be automatically disabled. An empty buffer
4224 accomplishes this, since that is also the representation for a list
4225 containing no features. */
4228 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
4231 struct cleanup
*old_chain
= make_cleanup (free_current_contents
, &q
);
4233 q
= remote_query_supported_append (q
, "multiprocess+");
4235 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4236 q
= remote_query_supported_append (q
, "swbreak+");
4237 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4238 q
= remote_query_supported_append (q
, "hwbreak+");
4240 if (remote_support_xml
)
4241 q
= remote_query_supported_append (q
, remote_support_xml
);
4243 q
= remote_query_supported_append (q
, "qRelocInsn+");
4247 if (packet_set_cmd_state (PACKET_fork_event_feature
)
4248 != AUTO_BOOLEAN_FALSE
)
4249 q
= remote_query_supported_append (q
, "fork-events+");
4250 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
4251 != AUTO_BOOLEAN_FALSE
)
4252 q
= remote_query_supported_append (q
, "vfork-events+");
4255 q
= reconcat (q
, "qSupported:", q
, (char *) NULL
);
4258 do_cleanups (old_chain
);
4260 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4262 /* If an error occured, warn, but do not return - just reset the
4263 buffer to empty and go on to disable features. */
4264 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
4267 warning (_("Remote failure reply: %s"), rs
->buf
);
4272 memset (seen
, 0, sizeof (seen
));
4277 enum packet_support is_supported
;
4278 char *p
, *end
, *name_end
, *value
;
4280 /* First separate out this item from the rest of the packet. If
4281 there's another item after this, we overwrite the separator
4282 (terminated strings are much easier to work with). */
4284 end
= strchr (p
, ';');
4287 end
= p
+ strlen (p
);
4297 warning (_("empty item in \"qSupported\" response"));
4302 name_end
= strchr (p
, '=');
4305 /* This is a name=value entry. */
4306 is_supported
= PACKET_ENABLE
;
4307 value
= name_end
+ 1;
4316 is_supported
= PACKET_ENABLE
;
4320 is_supported
= PACKET_DISABLE
;
4324 is_supported
= PACKET_SUPPORT_UNKNOWN
;
4328 warning (_("unrecognized item \"%s\" "
4329 "in \"qSupported\" response"), p
);
4335 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4336 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
4338 const struct protocol_feature
*feature
;
4341 feature
= &remote_protocol_features
[i
];
4342 feature
->func (feature
, is_supported
, value
);
4347 /* If we increased the packet size, make sure to increase the global
4348 buffer size also. We delay this until after parsing the entire
4349 qSupported packet, because this is the same buffer we were
4351 if (rs
->buf_size
< rs
->explicit_packet_size
)
4353 rs
->buf_size
= rs
->explicit_packet_size
;
4354 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
4357 /* Handle the defaults for unmentioned features. */
4358 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4361 const struct protocol_feature
*feature
;
4363 feature
= &remote_protocol_features
[i
];
4364 feature
->func (feature
, feature
->default_support
, NULL
);
4368 /* Remove any of the remote.c targets from target stack. Upper targets depend
4369 on it so remove them first. */
4372 remote_unpush_target (void)
4374 pop_all_targets_above (process_stratum
- 1);
4378 remote_open_1 (const char *name
, int from_tty
,
4379 struct target_ops
*target
, int extended_p
)
4381 struct remote_state
*rs
= get_remote_state ();
4384 error (_("To open a remote debug connection, you need to specify what\n"
4385 "serial device is attached to the remote system\n"
4386 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
4388 /* See FIXME above. */
4389 if (!target_async_permitted
)
4390 wait_forever_enabled_p
= 1;
4392 /* If we're connected to a running target, target_preopen will kill it.
4393 Ask this question first, before target_preopen has a chance to kill
4395 if (rs
->remote_desc
!= NULL
&& !have_inferiors ())
4398 && !query (_("Already connected to a remote target. Disconnect? ")))
4399 error (_("Still connected."));
4402 /* Here the possibly existing remote target gets unpushed. */
4403 target_preopen (from_tty
);
4405 /* Make sure we send the passed signals list the next time we resume. */
4406 xfree (rs
->last_pass_packet
);
4407 rs
->last_pass_packet
= NULL
;
4409 /* Make sure we send the program signals list the next time we
4411 xfree (rs
->last_program_signals_packet
);
4412 rs
->last_program_signals_packet
= NULL
;
4414 remote_fileio_reset ();
4415 reopen_exec_file ();
4418 rs
->remote_desc
= remote_serial_open (name
);
4419 if (!rs
->remote_desc
)
4420 perror_with_name (name
);
4422 if (baud_rate
!= -1)
4424 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
4426 /* The requested speed could not be set. Error out to
4427 top level after closing remote_desc. Take care to
4428 set remote_desc to NULL to avoid closing remote_desc
4430 serial_close (rs
->remote_desc
);
4431 rs
->remote_desc
= NULL
;
4432 perror_with_name (name
);
4436 serial_setparity (rs
->remote_desc
, serial_parity
);
4437 serial_raw (rs
->remote_desc
);
4439 /* If there is something sitting in the buffer we might take it as a
4440 response to a command, which would be bad. */
4441 serial_flush_input (rs
->remote_desc
);
4445 puts_filtered ("Remote debugging using ");
4446 puts_filtered (name
);
4447 puts_filtered ("\n");
4449 push_target (target
); /* Switch to using remote target now. */
4451 /* Register extra event sources in the event loop. */
4452 remote_async_inferior_event_token
4453 = create_async_event_handler (remote_async_inferior_event_handler
,
4455 rs
->notif_state
= remote_notif_state_allocate ();
4457 /* Reset the target state; these things will be queried either by
4458 remote_query_supported or as they are needed. */
4459 reset_all_packet_configs_support ();
4460 rs
->cached_wait_status
= 0;
4461 rs
->explicit_packet_size
= 0;
4463 rs
->extended
= extended_p
;
4464 rs
->waiting_for_stop_reply
= 0;
4465 rs
->ctrlc_pending_p
= 0;
4467 rs
->general_thread
= not_sent_ptid
;
4468 rs
->continue_thread
= not_sent_ptid
;
4469 rs
->remote_traceframe_number
= -1;
4471 /* Probe for ability to use "ThreadInfo" query, as required. */
4472 rs
->use_threadinfo_query
= 1;
4473 rs
->use_threadextra_query
= 1;
4475 if (target_async_permitted
)
4477 /* With this target we start out by owning the terminal. */
4478 remote_async_terminal_ours_p
= 1;
4480 /* FIXME: cagney/1999-09-23: During the initial connection it is
4481 assumed that the target is already ready and able to respond to
4482 requests. Unfortunately remote_start_remote() eventually calls
4483 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
4484 around this. Eventually a mechanism that allows
4485 wait_for_inferior() to expect/get timeouts will be
4487 wait_forever_enabled_p
= 0;
4490 /* First delete any symbols previously loaded from shared libraries. */
4491 no_shared_libraries (NULL
, 0);
4494 init_thread_list ();
4496 /* Start the remote connection. If error() or QUIT, discard this
4497 target (we'd otherwise be in an inconsistent state) and then
4498 propogate the error on up the exception chain. This ensures that
4499 the caller doesn't stumble along blindly assuming that the
4500 function succeeded. The CLI doesn't have this problem but other
4501 UI's, such as MI do.
4503 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
4504 this function should return an error indication letting the
4505 caller restore the previous state. Unfortunately the command
4506 ``target remote'' is directly wired to this function making that
4507 impossible. On a positive note, the CLI side of this problem has
4508 been fixed - the function set_cmd_context() makes it possible for
4509 all the ``target ....'' commands to share a common callback
4510 function. See cli-dump.c. */
4515 remote_start_remote (from_tty
, target
, extended_p
);
4517 CATCH (ex
, RETURN_MASK_ALL
)
4519 /* Pop the partially set up target - unless something else did
4520 already before throwing the exception. */
4521 if (rs
->remote_desc
!= NULL
)
4522 remote_unpush_target ();
4523 if (target_async_permitted
)
4524 wait_forever_enabled_p
= 1;
4525 throw_exception (ex
);
4530 remote_btrace_reset ();
4532 if (target_async_permitted
)
4533 wait_forever_enabled_p
= 1;
4536 /* Detach the specified process. */
4539 remote_detach_pid (int pid
)
4541 struct remote_state
*rs
= get_remote_state ();
4543 if (remote_multi_process_p (rs
))
4544 xsnprintf (rs
->buf
, get_remote_packet_size (), "D;%x", pid
);
4546 strcpy (rs
->buf
, "D");
4549 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4551 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
4553 else if (rs
->buf
[0] == '\0')
4554 error (_("Remote doesn't know how to detach"));
4556 error (_("Can't detach process."));
4559 /* This detaches a program to which we previously attached, using
4560 inferior_ptid to identify the process. After this is done, GDB
4561 can be used to debug some other program. We better not have left
4562 any breakpoints in the target program or it'll die when it hits
4566 remote_detach_1 (const char *args
, int from_tty
)
4568 int pid
= ptid_get_pid (inferior_ptid
);
4569 struct remote_state
*rs
= get_remote_state ();
4570 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
4574 error (_("Argument given to \"detach\" when remotely debugging."));
4576 if (!target_has_execution
)
4577 error (_("No process to detach from."));
4581 char *exec_file
= get_exec_file (0);
4582 if (exec_file
== NULL
)
4584 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
4585 target_pid_to_str (pid_to_ptid (pid
)));
4586 gdb_flush (gdb_stdout
);
4589 /* Tell the remote target to detach. */
4590 remote_detach_pid (pid
);
4592 if (from_tty
&& !rs
->extended
)
4593 puts_filtered (_("Ending remote debugging.\n"));
4595 /* Check to see if we are detaching a fork parent. Note that if we
4596 are detaching a fork child, tp == NULL. */
4597 is_fork_parent
= (tp
!= NULL
4598 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
4600 /* If doing detach-on-fork, we don't mourn, because that will delete
4601 breakpoints that should be available for the followed inferior. */
4602 if (!is_fork_parent
)
4603 target_mourn_inferior ();
4606 inferior_ptid
= null_ptid
;
4607 detach_inferior (pid
);
4612 remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
4614 remote_detach_1 (args
, from_tty
);
4618 extended_remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
4620 remote_detach_1 (args
, from_tty
);
4623 /* Target follow-fork function for remote targets. On entry, and
4624 at return, the current inferior is the fork parent.
4626 Note that although this is currently only used for extended-remote,
4627 it is named remote_follow_fork in anticipation of using it for the
4628 remote target as well. */
4631 remote_follow_fork (struct target_ops
*ops
, int follow_child
,
4634 struct remote_state
*rs
= get_remote_state ();
4635 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
4637 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
4638 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
4640 /* When following the parent and detaching the child, we detach
4641 the child here. For the case of following the child and
4642 detaching the parent, the detach is done in the target-
4643 independent follow fork code in infrun.c. We can't use
4644 target_detach when detaching an unfollowed child because
4645 the client side doesn't know anything about the child. */
4646 if (detach_fork
&& !follow_child
)
4648 /* Detach the fork child. */
4652 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
4653 child_pid
= ptid_get_pid (child_ptid
);
4655 remote_detach_pid (child_pid
);
4656 detach_inferior (child_pid
);
4662 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
4665 remote_disconnect (struct target_ops
*target
, const char *args
, int from_tty
)
4668 error (_("Argument given to \"disconnect\" when remotely debugging."));
4670 /* Make sure we unpush even the extended remote targets; mourn
4671 won't do it. So call remote_mourn directly instead of
4672 target_mourn_inferior. */
4673 remote_mourn (target
);
4676 puts_filtered ("Ending remote debugging.\n");
4679 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
4680 be chatty about it. */
4683 extended_remote_attach (struct target_ops
*target
, const char *args
,
4686 struct remote_state
*rs
= get_remote_state ();
4688 char *wait_status
= NULL
;
4690 pid
= parse_pid_to_attach (args
);
4692 /* Remote PID can be freely equal to getpid, do not check it here the same
4693 way as in other targets. */
4695 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
4696 error (_("This target does not support attaching to a process"));
4700 char *exec_file
= get_exec_file (0);
4703 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
4704 target_pid_to_str (pid_to_ptid (pid
)));
4706 printf_unfiltered (_("Attaching to %s\n"),
4707 target_pid_to_str (pid_to_ptid (pid
)));
4709 gdb_flush (gdb_stdout
);
4712 xsnprintf (rs
->buf
, get_remote_packet_size (), "vAttach;%x", pid
);
4714 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4716 switch (packet_ok (rs
->buf
,
4717 &remote_protocol_packets
[PACKET_vAttach
]))
4722 /* Save the reply for later. */
4723 wait_status
= alloca (strlen (rs
->buf
) + 1);
4724 strcpy (wait_status
, rs
->buf
);
4726 else if (strcmp (rs
->buf
, "OK") != 0)
4727 error (_("Attaching to %s failed with: %s"),
4728 target_pid_to_str (pid_to_ptid (pid
)),
4731 case PACKET_UNKNOWN
:
4732 error (_("This target does not support attaching to a process"));
4734 error (_("Attaching to %s failed"),
4735 target_pid_to_str (pid_to_ptid (pid
)));
4738 set_current_inferior (remote_add_inferior (0, pid
, 1, 0));
4740 inferior_ptid
= pid_to_ptid (pid
);
4744 struct thread_info
*thread
;
4746 /* Get list of threads. */
4747 remote_update_thread_list (target
);
4749 thread
= first_thread_of_process (pid
);
4751 inferior_ptid
= thread
->ptid
;
4753 inferior_ptid
= pid_to_ptid (pid
);
4755 /* Invalidate our notion of the remote current thread. */
4756 record_currthread (rs
, minus_one_ptid
);
4760 /* Now, if we have thread information, update inferior_ptid. */
4761 inferior_ptid
= remote_current_thread (inferior_ptid
);
4763 /* Add the main thread to the thread list. */
4764 add_thread_silent (inferior_ptid
);
4767 /* Next, if the target can specify a description, read it. We do
4768 this before anything involving memory or registers. */
4769 target_find_description ();
4773 /* Use the previously fetched status. */
4774 gdb_assert (wait_status
!= NULL
);
4776 if (target_can_async_p ())
4778 struct notif_event
*reply
4779 = remote_notif_parse (¬if_client_stop
, wait_status
);
4781 push_stop_reply ((struct stop_reply
*) reply
);
4787 gdb_assert (wait_status
!= NULL
);
4788 strcpy (rs
->buf
, wait_status
);
4789 rs
->cached_wait_status
= 1;
4793 gdb_assert (wait_status
== NULL
);
4796 /* Implementation of the to_post_attach method. */
4799 extended_remote_post_attach (struct target_ops
*ops
, int pid
)
4801 /* In certain cases GDB might not have had the chance to start
4802 symbol lookup up until now. This could happen if the debugged
4803 binary is not using shared libraries, the vsyscall page is not
4804 present (on Linux) and the binary itself hadn't changed since the
4805 debugging process was started. */
4806 if (symfile_objfile
!= NULL
)
4807 remote_check_symbols();
4811 /* Check for the availability of vCont. This function should also check
4815 remote_vcont_probe (struct remote_state
*rs
)
4819 strcpy (rs
->buf
, "vCont?");
4821 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4824 /* Make sure that the features we assume are supported. */
4825 if (startswith (buf
, "vCont"))
4828 int support_s
, support_S
, support_c
, support_C
;
4834 rs
->supports_vCont
.t
= 0;
4835 rs
->supports_vCont
.r
= 0;
4836 while (p
&& *p
== ';')
4839 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4841 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4843 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4845 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4847 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4848 rs
->supports_vCont
.t
= 1;
4849 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4850 rs
->supports_vCont
.r
= 1;
4852 p
= strchr (p
, ';');
4855 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
4856 BUF will make packet_ok disable the packet. */
4857 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
4861 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
4864 /* Helper function for building "vCont" resumptions. Write a
4865 resumption to P. ENDP points to one-passed-the-end of the buffer
4866 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
4867 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
4868 resumed thread should be single-stepped and/or signalled. If PTID
4869 equals minus_one_ptid, then all threads are resumed; if PTID
4870 represents a process, then all threads of the process are resumed;
4871 the thread to be stepped and/or signalled is given in the global
4875 append_resumption (char *p
, char *endp
,
4876 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
4878 struct remote_state
*rs
= get_remote_state ();
4880 if (step
&& siggnal
!= GDB_SIGNAL_0
)
4881 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
4883 /* GDB is willing to range step. */
4884 && use_range_stepping
4885 /* Target supports range stepping. */
4886 && rs
->supports_vCont
.r
4887 /* We don't currently support range stepping multiple
4888 threads with a wildcard (though the protocol allows it,
4889 so stubs shouldn't make an active effort to forbid
4891 && !(remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
4893 struct thread_info
*tp
;
4895 if (ptid_equal (ptid
, minus_one_ptid
))
4897 /* If we don't know about the target thread's tid, then
4898 we're resuming magic_null_ptid (see caller). */
4899 tp
= find_thread_ptid (magic_null_ptid
);
4902 tp
= find_thread_ptid (ptid
);
4903 gdb_assert (tp
!= NULL
);
4905 if (tp
->control
.may_range_step
)
4907 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4909 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
4910 phex_nz (tp
->control
.step_range_start
,
4912 phex_nz (tp
->control
.step_range_end
,
4916 p
+= xsnprintf (p
, endp
- p
, ";s");
4919 p
+= xsnprintf (p
, endp
- p
, ";s");
4920 else if (siggnal
!= GDB_SIGNAL_0
)
4921 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
4923 p
+= xsnprintf (p
, endp
- p
, ";c");
4925 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
4929 /* All (-1) threads of process. */
4930 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
4932 p
+= xsnprintf (p
, endp
- p
, ":");
4933 p
= write_ptid (p
, endp
, nptid
);
4935 else if (!ptid_equal (ptid
, minus_one_ptid
))
4937 p
+= xsnprintf (p
, endp
- p
, ":");
4938 p
= write_ptid (p
, endp
, ptid
);
4944 /* Append a vCont continue-with-signal action for threads that have a
4945 non-zero stop signal. */
4948 append_pending_thread_resumptions (char *p
, char *endp
, ptid_t ptid
)
4950 struct thread_info
*thread
;
4952 ALL_NON_EXITED_THREADS (thread
)
4953 if (ptid_match (thread
->ptid
, ptid
)
4954 && !ptid_equal (inferior_ptid
, thread
->ptid
)
4955 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
4957 p
= append_resumption (p
, endp
, thread
->ptid
,
4958 0, thread
->suspend
.stop_signal
);
4959 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4965 /* Resume the remote inferior by using a "vCont" packet. The thread
4966 to be resumed is PTID; STEP and SIGGNAL indicate whether the
4967 resumed thread should be single-stepped and/or signalled. If PTID
4968 equals minus_one_ptid, then all threads are resumed; the thread to
4969 be stepped and/or signalled is given in the global INFERIOR_PTID.
4970 This function returns non-zero iff it resumes the inferior.
4972 This function issues a strict subset of all possible vCont commands at the
4976 remote_vcont_resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
4978 struct remote_state
*rs
= get_remote_state ();
4982 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
4983 remote_vcont_probe (rs
);
4985 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
4989 endp
= rs
->buf
+ get_remote_packet_size ();
4991 /* If we could generate a wider range of packets, we'd have to worry
4992 about overflowing BUF. Should there be a generic
4993 "multi-part-packet" packet? */
4995 p
+= xsnprintf (p
, endp
- p
, "vCont");
4997 if (ptid_equal (ptid
, magic_null_ptid
))
4999 /* MAGIC_NULL_PTID means that we don't have any active threads,
5000 so we don't have any TID numbers the inferior will
5001 understand. Make sure to only send forms that do not specify
5003 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
5005 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
5007 /* Resume all threads (of all processes, or of a single
5008 process), with preference for INFERIOR_PTID. This assumes
5009 inferior_ptid belongs to the set of all threads we are about
5011 if (step
|| siggnal
!= GDB_SIGNAL_0
)
5013 /* Step inferior_ptid, with or without signal. */
5014 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
5017 /* Also pass down any pending signaled resumption for other
5018 threads not the current. */
5019 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
5021 /* And continue others without a signal. */
5022 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
5026 /* Scheduler locking; resume only PTID. */
5027 append_resumption (p
, endp
, ptid
, step
, siggnal
);
5030 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
5035 /* In non-stop, the stub replies to vCont with "OK". The stop
5036 reply will be reported asynchronously by means of a `%Stop'
5038 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5039 if (strcmp (rs
->buf
, "OK") != 0)
5040 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5046 /* Tell the remote machine to resume. */
5049 remote_resume (struct target_ops
*ops
,
5050 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5052 struct remote_state
*rs
= get_remote_state ();
5055 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5056 (explained in remote-notif.c:handle_notification) so
5057 remote_notif_process is not called. We need find a place where
5058 it is safe to start a 'vNotif' sequence. It is good to do it
5059 before resuming inferior, because inferior was stopped and no RSP
5060 traffic at that moment. */
5062 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
5064 rs
->last_sent_signal
= siggnal
;
5065 rs
->last_sent_step
= step
;
5067 /* The vCont packet doesn't need to specify threads via Hc. */
5068 /* No reverse support (yet) for vCont. */
5069 if (execution_direction
!= EXEC_REVERSE
)
5070 if (remote_vcont_resume (ptid
, step
, siggnal
))
5073 /* All other supported resume packets do use Hc, so set the continue
5075 if (ptid_equal (ptid
, minus_one_ptid
))
5076 set_continue_thread (any_thread_ptid
);
5078 set_continue_thread (ptid
);
5081 if (execution_direction
== EXEC_REVERSE
)
5083 /* We don't pass signals to the target in reverse exec mode. */
5084 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
5085 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5088 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
5089 error (_("Remote reverse-step not supported."));
5090 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
5091 error (_("Remote reverse-continue not supported."));
5093 strcpy (buf
, step
? "bs" : "bc");
5095 else if (siggnal
!= GDB_SIGNAL_0
)
5097 buf
[0] = step
? 'S' : 'C';
5098 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
5099 buf
[2] = tohex (((int) siggnal
) & 0xf);
5103 strcpy (buf
, step
? "s" : "c");
5108 /* We are about to start executing the inferior, let's register it
5109 with the event loop. NOTE: this is the one place where all the
5110 execution commands end up. We could alternatively do this in each
5111 of the execution commands in infcmd.c. */
5112 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5113 into infcmd.c in order to allow inferior function calls to work
5114 NOT asynchronously. */
5115 if (target_can_async_p ())
5118 /* We've just told the target to resume. The remote server will
5119 wait for the inferior to stop, and then send a stop reply. In
5120 the mean time, we can't start another command/query ourselves
5121 because the stub wouldn't be ready to process it. This applies
5122 only to the base all-stop protocol, however. In non-stop (which
5123 only supports vCont), the stub replies with an "OK", and is
5124 immediate able to process further serial input. */
5126 rs
->waiting_for_stop_reply
= 1;
5130 /* Set up the signal handler for SIGINT, while the target is
5131 executing, ovewriting the 'regular' SIGINT signal handler. */
5133 async_initialize_sigint_signal_handler (void)
5135 signal (SIGINT
, async_handle_remote_sigint
);
5138 /* Signal handler for SIGINT, while the target is executing. */
5140 async_handle_remote_sigint (int sig
)
5142 signal (sig
, async_handle_remote_sigint_twice
);
5143 /* Note we need to go through gdb_call_async_signal_handler in order
5144 to wake up the event loop on Windows. */
5145 gdb_call_async_signal_handler (async_sigint_remote_token
, 0);
5148 /* Signal handler for SIGINT, installed after SIGINT has already been
5149 sent once. It will take effect the second time that the user sends
5152 async_handle_remote_sigint_twice (int sig
)
5154 signal (sig
, async_handle_remote_sigint
);
5155 /* See note in async_handle_remote_sigint. */
5156 gdb_call_async_signal_handler (async_sigint_remote_twice_token
, 0);
5159 /* Perform the real interruption of the target execution, in response
5162 async_remote_interrupt (gdb_client_data arg
)
5165 fprintf_unfiltered (gdb_stdlog
, "async_remote_interrupt called\n");
5167 target_stop (inferior_ptid
);
5170 /* Perform interrupt, if the first attempt did not succeed. Just give
5171 up on the target alltogether. */
5173 async_remote_interrupt_twice (gdb_client_data arg
)
5176 fprintf_unfiltered (gdb_stdlog
, "async_remote_interrupt_twice called\n");
5181 /* Reinstall the usual SIGINT handlers, after the target has
5184 async_cleanup_sigint_signal_handler (void *dummy
)
5186 signal (SIGINT
, handle_sigint
);
5189 /* Send ^C to target to halt it. Target will respond, and send us a
5191 static void (*ofunc
) (int);
5193 /* The command line interface's stop routine. This function is installed
5194 as a signal handler for SIGINT. The first time a user requests a
5195 stop, we call remote_stop to send a break or ^C. If there is no
5196 response from the target (it didn't stop when the user requested it),
5197 we ask the user if he'd like to detach from the target. */
5199 sync_remote_interrupt (int signo
)
5201 /* If this doesn't work, try more severe steps. */
5202 signal (signo
, sync_remote_interrupt_twice
);
5204 gdb_call_async_signal_handler (async_sigint_remote_token
, 1);
5207 /* The user typed ^C twice. */
5210 sync_remote_interrupt_twice (int signo
)
5212 signal (signo
, ofunc
);
5213 gdb_call_async_signal_handler (async_sigint_remote_twice_token
, 1);
5214 signal (signo
, sync_remote_interrupt
);
5217 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
5218 thread, all threads of a remote process, or all threads of all
5222 remote_stop_ns (ptid_t ptid
)
5224 struct remote_state
*rs
= get_remote_state ();
5226 char *endp
= rs
->buf
+ get_remote_packet_size ();
5228 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
5229 remote_vcont_probe (rs
);
5231 if (!rs
->supports_vCont
.t
)
5232 error (_("Remote server does not support stopping threads"));
5234 if (ptid_equal (ptid
, minus_one_ptid
)
5235 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
5236 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
5241 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
5243 if (ptid_is_pid (ptid
))
5244 /* All (-1) threads of process. */
5245 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
5248 /* Small optimization: if we already have a stop reply for
5249 this thread, no use in telling the stub we want this
5251 if (peek_stop_reply (ptid
))
5257 write_ptid (p
, endp
, nptid
);
5260 /* In non-stop, we get an immediate OK reply. The stop reply will
5261 come in asynchronously by notification. */
5263 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5264 if (strcmp (rs
->buf
, "OK") != 0)
5265 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
5268 /* All-stop version of target_stop. Sends a break or a ^C to stop the
5269 remote target. It is undefined which thread of which process
5270 reports the stop. */
5273 remote_stop_as (ptid_t ptid
)
5275 struct remote_state
*rs
= get_remote_state ();
5277 rs
->ctrlc_pending_p
= 1;
5279 /* If the inferior is stopped already, but the core didn't know
5280 about it yet, just ignore the request. The cached wait status
5281 will be collected in remote_wait. */
5282 if (rs
->cached_wait_status
)
5285 /* Send interrupt_sequence to remote target. */
5286 send_interrupt_sequence ();
5289 /* This is the generic stop called via the target vector. When a target
5290 interrupt is requested, either by the command line or the GUI, we
5291 will eventually end up here. */
5294 remote_stop (struct target_ops
*self
, ptid_t ptid
)
5297 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
5300 remote_stop_ns (ptid
);
5302 remote_stop_as (ptid
);
5305 /* Ask the user what to do when an interrupt is received. */
5308 interrupt_query (void)
5310 target_terminal_ours ();
5312 if (target_is_async_p ())
5314 signal (SIGINT
, handle_sigint
);
5319 if (query (_("Interrupted while waiting for the program.\n\
5320 Give up (and stop debugging it)? ")))
5322 remote_unpush_target ();
5327 target_terminal_inferior ();
5330 /* Enable/disable target terminal ownership. Most targets can use
5331 terminal groups to control terminal ownership. Remote targets are
5332 different in that explicit transfer of ownership to/from GDB/target
5336 remote_terminal_inferior (struct target_ops
*self
)
5338 if (!target_async_permitted
)
5339 /* Nothing to do. */
5342 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
5343 idempotent. The event-loop GDB talking to an asynchronous target
5344 with a synchronous command calls this function from both
5345 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
5346 transfer the terminal to the target when it shouldn't this guard
5348 if (!remote_async_terminal_ours_p
)
5350 delete_file_handler (input_fd
);
5351 remote_async_terminal_ours_p
= 0;
5352 async_initialize_sigint_signal_handler ();
5353 /* NOTE: At this point we could also register our selves as the
5354 recipient of all input. Any characters typed could then be
5355 passed on down to the target. */
5359 remote_terminal_ours (struct target_ops
*self
)
5361 if (!target_async_permitted
)
5362 /* Nothing to do. */
5365 /* See FIXME in remote_terminal_inferior. */
5366 if (remote_async_terminal_ours_p
)
5368 async_cleanup_sigint_signal_handler (NULL
);
5369 add_file_handler (input_fd
, stdin_event_handler
, 0);
5370 remote_async_terminal_ours_p
= 1;
5374 remote_console_output (char *msg
)
5378 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
5381 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
5385 fputs_unfiltered (tb
, gdb_stdtarg
);
5387 gdb_flush (gdb_stdtarg
);
5390 typedef struct cached_reg
5393 gdb_byte data
[MAX_REGISTER_SIZE
];
5396 DEF_VEC_O(cached_reg_t
);
5398 typedef struct stop_reply
5400 struct notif_event base
;
5402 /* The identifier of the thread about this event */
5405 /* The remote state this event is associated with. When the remote
5406 connection, represented by a remote_state object, is closed,
5407 all the associated stop_reply events should be released. */
5408 struct remote_state
*rs
;
5410 struct target_waitstatus ws
;
5412 /* Expedited registers. This makes remote debugging a bit more
5413 efficient for those targets that provide critical registers as
5414 part of their normal status mechanism (as another roundtrip to
5415 fetch them is avoided). */
5416 VEC(cached_reg_t
) *regcache
;
5418 enum target_stop_reason stop_reason
;
5420 CORE_ADDR watch_data_address
;
5425 DECLARE_QUEUE_P (stop_reply_p
);
5426 DEFINE_QUEUE_P (stop_reply_p
);
5427 /* The list of already fetched and acknowledged stop events. This
5428 queue is used for notification Stop, and other notifications
5429 don't need queue for their events, because the notification events
5430 of Stop can't be consumed immediately, so that events should be
5431 queued first, and be consumed by remote_wait_{ns,as} one per
5432 time. Other notifications can consume their events immediately,
5433 so queue is not needed for them. */
5434 static QUEUE (stop_reply_p
) *stop_reply_queue
;
5437 stop_reply_xfree (struct stop_reply
*r
)
5439 notif_event_xfree ((struct notif_event
*) r
);
5443 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
5444 struct notif_event
*event
)
5446 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
5450 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
5451 struct notif_event
*event
)
5453 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
5456 putpkt ((char *) self
->ack_command
);
5458 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
5459 /* We got an unknown stop reply. */
5460 error (_("Unknown stop reply"));
5462 push_stop_reply (stop_reply
);
5466 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
5468 /* We can't get pending events in remote_notif_process for
5469 notification stop, and we have to do this in remote_wait_ns
5470 instead. If we fetch all queued events from stub, remote stub
5471 may exit and we have no chance to process them back in
5473 mark_async_event_handler (remote_async_inferior_event_token
);
5478 stop_reply_dtr (struct notif_event
*event
)
5480 struct stop_reply
*r
= (struct stop_reply
*) event
;
5482 VEC_free (cached_reg_t
, r
->regcache
);
5485 static struct notif_event
*
5486 remote_notif_stop_alloc_reply (void)
5488 struct notif_event
*r
5489 = (struct notif_event
*) XNEW (struct stop_reply
);
5491 r
->dtr
= stop_reply_dtr
;
5496 /* A client of notification Stop. */
5498 struct notif_client notif_client_stop
=
5502 remote_notif_stop_parse
,
5503 remote_notif_stop_ack
,
5504 remote_notif_stop_can_get_pending_events
,
5505 remote_notif_stop_alloc_reply
,
5509 /* A parameter to pass data in and out. */
5511 struct queue_iter_param
5514 struct stop_reply
*output
;
5517 /* Determine if THREAD is a pending fork parent thread. ARG contains
5518 the pid of the process that owns the threads we want to check, or
5519 -1 if we want to check all threads. */
5522 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
5525 if (ws
->kind
== TARGET_WAITKIND_FORKED
5526 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
5528 if (event_pid
== -1 || event_pid
== ptid_get_pid (thread_ptid
))
5535 /* Check whether EVENT is a fork event, and if it is, remove the
5536 fork child from the context list passed in DATA. */
5539 remove_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
5540 QUEUE_ITER (stop_reply_p
) *iter
,
5544 struct queue_iter_param
*param
= data
;
5545 struct threads_listing_context
*context
= param
->input
;
5547 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
5548 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
5550 threads_listing_context_remove (&event
->ws
, context
);
5556 /* If CONTEXT contains any fork child threads that have not been
5557 reported yet, remove them from the CONTEXT list. If such a
5558 thread exists it is because we are stopped at a fork catchpoint
5559 and have not yet called follow_fork, which will set up the
5560 host-side data structures for the new process. */
5563 remove_new_fork_children (struct threads_listing_context
*context
)
5565 struct thread_info
* thread
;
5567 struct notif_client
*notif
= ¬if_client_stop
;
5568 struct queue_iter_param param
;
5570 /* For any threads stopped at a fork event, remove the corresponding
5571 fork child threads from the CONTEXT list. */
5572 ALL_NON_EXITED_THREADS (thread
)
5574 struct target_waitstatus
*ws
= &thread
->pending_follow
;
5576 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
5578 threads_listing_context_remove (ws
, context
);
5582 /* Check for any pending fork events (not reported or processed yet)
5583 in process PID and remove those fork child threads from the
5584 CONTEXT list as well. */
5585 remote_notif_get_pending_events (notif
);
5586 param
.input
= context
;
5587 param
.output
= NULL
;
5588 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5589 remove_child_of_pending_fork
, ¶m
);
5592 /* Remove stop replies in the queue if its pid is equal to the given
5596 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
5597 QUEUE_ITER (stop_reply_p
) *iter
,
5601 struct queue_iter_param
*param
= data
;
5602 struct inferior
*inf
= param
->input
;
5604 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
5606 stop_reply_xfree (event
);
5607 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
5613 /* Discard all pending stop replies of inferior INF. */
5616 discard_pending_stop_replies (struct inferior
*inf
)
5619 struct queue_iter_param param
;
5620 struct stop_reply
*reply
;
5621 struct remote_state
*rs
= get_remote_state ();
5622 struct remote_notif_state
*rns
= rs
->notif_state
;
5624 /* This function can be notified when an inferior exists. When the
5625 target is not remote, the notification state is NULL. */
5626 if (rs
->remote_desc
== NULL
)
5629 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
5631 /* Discard the in-flight notification. */
5632 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
5634 stop_reply_xfree (reply
);
5635 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
5639 param
.output
= NULL
;
5640 /* Discard the stop replies we have already pulled with
5642 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5643 remove_stop_reply_for_inferior
, ¶m
);
5646 /* If its remote state is equal to the given remote state,
5647 remove EVENT from the stop reply queue. */
5650 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
5651 QUEUE_ITER (stop_reply_p
) *iter
,
5655 struct queue_iter_param
*param
= data
;
5656 struct remote_state
*rs
= param
->input
;
5658 if (event
->rs
== rs
)
5660 stop_reply_xfree (event
);
5661 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
5667 /* Discard the stop replies for RS in stop_reply_queue. */
5670 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
5672 struct queue_iter_param param
;
5675 param
.output
= NULL
;
5676 /* Discard the stop replies we have already pulled with
5678 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5679 remove_stop_reply_of_remote_state
, ¶m
);
5682 /* A parameter to pass data in and out. */
5685 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
5686 QUEUE_ITER (stop_reply_p
) *iter
,
5690 struct queue_iter_param
*param
= data
;
5691 ptid_t
*ptid
= param
->input
;
5693 if (ptid_match (event
->ptid
, *ptid
))
5695 param
->output
= event
;
5696 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
5703 /* Remove the first reply in 'stop_reply_queue' which matches
5706 static struct stop_reply
*
5707 remote_notif_remove_queued_reply (ptid_t ptid
)
5709 struct queue_iter_param param
;
5711 param
.input
= &ptid
;
5712 param
.output
= NULL
;
5714 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5715 remote_notif_remove_once_on_match
, ¶m
);
5717 fprintf_unfiltered (gdb_stdlog
,
5718 "notif: discard queued event: 'Stop' in %s\n",
5719 target_pid_to_str (ptid
));
5721 return param
.output
;
5724 /* Look for a queued stop reply belonging to PTID. If one is found,
5725 remove it from the queue, and return it. Returns NULL if none is
5726 found. If there are still queued events left to process, tell the
5727 event loop to get back to target_wait soon. */
5729 static struct stop_reply
*
5730 queued_stop_reply (ptid_t ptid
)
5732 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
5734 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
5735 /* There's still at least an event left. */
5736 mark_async_event_handler (remote_async_inferior_event_token
);
5741 /* Push a fully parsed stop reply in the stop reply queue. Since we
5742 know that we now have at least one queued event left to pass to the
5743 core side, tell the event loop to get back to target_wait soon. */
5746 push_stop_reply (struct stop_reply
*new_event
)
5748 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
5751 fprintf_unfiltered (gdb_stdlog
,
5752 "notif: push 'Stop' %s to queue %d\n",
5753 target_pid_to_str (new_event
->ptid
),
5754 QUEUE_length (stop_reply_p
,
5757 mark_async_event_handler (remote_async_inferior_event_token
);
5761 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
5762 QUEUE_ITER (stop_reply_p
) *iter
,
5763 struct stop_reply
*event
,
5766 ptid_t
*ptid
= data
;
5768 return !(ptid_equal (*ptid
, event
->ptid
)
5769 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5772 /* Returns true if we have a stop reply for PTID. */
5775 peek_stop_reply (ptid_t ptid
)
5777 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5778 stop_reply_match_ptid_and_ws
, &ptid
);
5781 /* Skip PACKET until the next semi-colon (or end of string). */
5784 skip_to_semicolon (char *p
)
5786 while (*p
!= '\0' && *p
!= ';')
5791 /* Parse the stop reply in BUF. Either the function succeeds, and the
5792 result is stored in EVENT, or throws an error. */
5795 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
5797 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5801 event
->ptid
= null_ptid
;
5802 event
->rs
= get_remote_state ();
5803 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
5804 event
->ws
.value
.integer
= 0;
5805 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
5806 event
->regcache
= NULL
;
5811 case 'T': /* Status with PC, SP, FP, ... */
5812 /* Expedited reply, containing Signal, {regno, reg} repeat. */
5813 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
5815 n... = register number
5816 r... = register contents
5819 p
= &buf
[3]; /* after Txx */
5825 p1
= strchr (p
, ':');
5827 error (_("Malformed packet(a) (missing colon): %s\n\
5831 error (_("Malformed packet(a) (missing register number): %s\n\
5835 /* Some "registers" are actually extended stop information.
5836 Note if you're adding a new entry here: GDB 7.9 and
5837 earlier assume that all register "numbers" that start
5838 with an hex digit are real register numbers. Make sure
5839 the server only sends such a packet if it knows the
5840 client understands it. */
5842 if (strncmp (p
, "thread", p1
- p
) == 0)
5843 event
->ptid
= read_ptid (++p1
, &p
);
5844 else if ((strncmp (p
, "watch", p1
- p
) == 0)
5845 || (strncmp (p
, "rwatch", p1
- p
) == 0)
5846 || (strncmp (p
, "awatch", p1
- p
) == 0))
5848 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
5849 p
= unpack_varlen_hex (++p1
, &addr
);
5850 event
->watch_data_address
= (CORE_ADDR
) addr
;
5852 else if (strncmp (p
, "swbreak", p1
- p
) == 0)
5854 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
5856 /* Make sure the stub doesn't forget to indicate support
5858 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
5859 error (_("Unexpected swbreak stop reason"));
5861 /* The value part is documented as "must be empty",
5862 though we ignore it, in case we ever decide to make
5863 use of it in a backward compatible way. */
5864 p
= skip_to_semicolon (p1
+ 1);
5866 else if (strncmp (p
, "hwbreak", p1
- p
) == 0)
5868 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
5870 /* Make sure the stub doesn't forget to indicate support
5872 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
5873 error (_("Unexpected hwbreak stop reason"));
5876 p
= skip_to_semicolon (p1
+ 1);
5878 else if (strncmp (p
, "library", p1
- p
) == 0)
5880 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
5881 p
= skip_to_semicolon (p1
+ 1);
5883 else if (strncmp (p
, "replaylog", p1
- p
) == 0)
5885 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
5886 /* p1 will indicate "begin" or "end", but it makes
5887 no difference for now, so ignore it. */
5888 p
= skip_to_semicolon (p1
+ 1);
5890 else if (strncmp (p
, "core", p1
- p
) == 0)
5894 p
= unpack_varlen_hex (++p1
, &c
);
5897 else if (strncmp (p
, "fork", p1
- p
) == 0)
5899 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
5900 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
5902 else if (strncmp (p
, "vfork", p1
- p
) == 0)
5904 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
5905 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
5907 else if (strncmp (p
, "vforkdone", p1
- p
) == 0)
5909 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
5910 p
= skip_to_semicolon (p1
+ 1);
5917 /* Maybe a real ``P'' register number. */
5918 p_temp
= unpack_varlen_hex (p
, &pnum
);
5919 /* If the first invalid character is the colon, we got a
5920 register number. Otherwise, it's an unknown stop
5924 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
5925 cached_reg_t cached_reg
;
5928 error (_("Remote sent bad register number %s: %s\n\
5930 hex_string (pnum
), p
, buf
);
5932 cached_reg
.num
= reg
->regnum
;
5935 fieldsize
= hex2bin (p
, cached_reg
.data
,
5936 register_size (target_gdbarch (),
5939 if (fieldsize
< register_size (target_gdbarch (),
5941 warning (_("Remote reply is too short: %s"), buf
);
5943 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
5947 /* Not a number. Silently skip unknown optional
5949 p
= skip_to_semicolon (p1
+ 1);
5954 error (_("Remote register badly formatted: %s\nhere: %s"),
5959 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
5963 case 'S': /* Old style status, just signal only. */
5967 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
5968 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
5969 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
5970 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
5972 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
5975 case 'W': /* Target exited. */
5982 /* GDB used to accept only 2 hex chars here. Stubs should
5983 only send more if they detect GDB supports multi-process
5985 p
= unpack_varlen_hex (&buf
[1], &value
);
5989 /* The remote process exited. */
5990 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
5991 event
->ws
.value
.integer
= value
;
5995 /* The remote process exited with a signal. */
5996 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
5997 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
5998 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
6000 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
6003 /* If no process is specified, assume inferior_ptid. */
6004 pid
= ptid_get_pid (inferior_ptid
);
6013 else if (startswith (p
, "process:"))
6017 p
+= sizeof ("process:") - 1;
6018 unpack_varlen_hex (p
, &upid
);
6022 error (_("unknown stop reply packet: %s"), buf
);
6025 error (_("unknown stop reply packet: %s"), buf
);
6026 event
->ptid
= pid_to_ptid (pid
);
6031 if (non_stop
&& ptid_equal (event
->ptid
, null_ptid
))
6032 error (_("No process or thread specified in stop reply: %s"), buf
);
6035 /* When the stub wants to tell GDB about a new notification reply, it
6036 sends a notification (%Stop, for example). Those can come it at
6037 any time, hence, we have to make sure that any pending
6038 putpkt/getpkt sequence we're making is finished, before querying
6039 the stub for more events with the corresponding ack command
6040 (vStopped, for example). E.g., if we started a vStopped sequence
6041 immediately upon receiving the notification, something like this
6049 1.6) <-- (registers reply to step #1.3)
6051 Obviously, the reply in step #1.6 would be unexpected to a vStopped
6054 To solve this, whenever we parse a %Stop notification successfully,
6055 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
6056 doing whatever we were doing:
6062 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
6063 2.5) <-- (registers reply to step #2.3)
6065 Eventualy after step #2.5, we return to the event loop, which
6066 notices there's an event on the
6067 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
6068 associated callback --- the function below. At this point, we're
6069 always safe to start a vStopped sequence. :
6072 2.7) <-- T05 thread:2
6078 remote_notif_get_pending_events (struct notif_client
*nc
)
6080 struct remote_state
*rs
= get_remote_state ();
6082 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
6085 fprintf_unfiltered (gdb_stdlog
,
6086 "notif: process: '%s' ack pending event\n",
6090 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
6091 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
6095 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6096 if (strcmp (rs
->buf
, "OK") == 0)
6099 remote_notif_ack (nc
, rs
->buf
);
6105 fprintf_unfiltered (gdb_stdlog
,
6106 "notif: process: '%s' no pending reply\n",
6111 /* Called when it is decided that STOP_REPLY holds the info of the
6112 event that is to be returned to the core. This function always
6113 destroys STOP_REPLY. */
6116 process_stop_reply (struct stop_reply
*stop_reply
,
6117 struct target_waitstatus
*status
)
6121 *status
= stop_reply
->ws
;
6122 ptid
= stop_reply
->ptid
;
6124 /* If no thread/process was reported by the stub, assume the current
6126 if (ptid_equal (ptid
, null_ptid
))
6127 ptid
= inferior_ptid
;
6129 if (status
->kind
!= TARGET_WAITKIND_EXITED
6130 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
6132 struct remote_state
*rs
= get_remote_state ();
6134 /* Expedited registers. */
6135 if (stop_reply
->regcache
)
6137 struct regcache
*regcache
6138 = get_thread_arch_regcache (ptid
, target_gdbarch ());
6143 VEC_iterate(cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
6145 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
6146 VEC_free (cached_reg_t
, stop_reply
->regcache
);
6149 rs
->stop_reason
= stop_reply
->stop_reason
;
6150 rs
->remote_watch_data_address
= stop_reply
->watch_data_address
;
6152 remote_notice_new_inferior (ptid
, 0);
6153 demand_private_info (ptid
)->core
= stop_reply
->core
;
6156 stop_reply_xfree (stop_reply
);
6160 /* The non-stop mode version of target_wait. */
6163 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
6165 struct remote_state
*rs
= get_remote_state ();
6166 struct stop_reply
*stop_reply
;
6170 /* If in non-stop mode, get out of getpkt even if a
6171 notification is received. */
6173 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
6174 0 /* forever */, &is_notif
);
6177 if (ret
!= -1 && !is_notif
)
6180 case 'E': /* Error of some sort. */
6181 /* We're out of sync with the target now. Did it continue
6182 or not? We can't tell which thread it was in non-stop,
6183 so just ignore this. */
6184 warning (_("Remote failure reply: %s"), rs
->buf
);
6186 case 'O': /* Console output. */
6187 remote_console_output (rs
->buf
+ 1);
6190 warning (_("Invalid remote reply: %s"), rs
->buf
);
6194 /* Acknowledge a pending stop reply that may have arrived in the
6196 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
6197 remote_notif_get_pending_events (¬if_client_stop
);
6199 /* If indeed we noticed a stop reply, we're done. */
6200 stop_reply
= queued_stop_reply (ptid
);
6201 if (stop_reply
!= NULL
)
6202 return process_stop_reply (stop_reply
, status
);
6204 /* Still no event. If we're just polling for an event, then
6205 return to the event loop. */
6206 if (options
& TARGET_WNOHANG
)
6208 status
->kind
= TARGET_WAITKIND_IGNORE
;
6209 return minus_one_ptid
;
6212 /* Otherwise do a blocking wait. */
6213 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
6214 1 /* forever */, &is_notif
);
6218 /* Wait until the remote machine stops, then return, storing status in
6219 STATUS just as `wait' would. */
6222 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
6224 struct remote_state
*rs
= get_remote_state ();
6225 ptid_t event_ptid
= null_ptid
;
6227 struct stop_reply
*stop_reply
;
6231 status
->kind
= TARGET_WAITKIND_IGNORE
;
6232 status
->value
.integer
= 0;
6234 stop_reply
= queued_stop_reply (ptid
);
6235 if (stop_reply
!= NULL
)
6236 return process_stop_reply (stop_reply
, status
);
6238 if (rs
->cached_wait_status
)
6239 /* Use the cached wait status, but only once. */
6240 rs
->cached_wait_status
= 0;
6246 if (!target_is_async_p ())
6248 ofunc
= signal (SIGINT
, sync_remote_interrupt
);
6249 /* If the user hit C-c before this packet, or between packets,
6250 pretend that it was hit right here. */
6251 if (check_quit_flag ())
6254 sync_remote_interrupt (SIGINT
);
6258 /* FIXME: cagney/1999-09-27: If we're in async mode we should
6259 _never_ wait for ever -> test on target_is_async_p().
6260 However, before we do that we need to ensure that the caller
6261 knows how to take the target into/out of async mode. */
6262 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
6263 wait_forever_enabled_p
, &is_notif
);
6265 if (!target_is_async_p ())
6266 signal (SIGINT
, ofunc
);
6268 /* GDB gets a notification. Return to core as this event is
6270 if (ret
!= -1 && is_notif
)
6271 return minus_one_ptid
;
6276 rs
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6278 /* We got something. */
6279 rs
->waiting_for_stop_reply
= 0;
6281 /* Assume that the target has acknowledged Ctrl-C unless we receive
6282 an 'F' or 'O' packet. */
6283 if (buf
[0] != 'F' && buf
[0] != 'O')
6284 rs
->ctrlc_pending_p
= 0;
6288 case 'E': /* Error of some sort. */
6289 /* We're out of sync with the target now. Did it continue or
6290 not? Not is more likely, so report a stop. */
6291 warning (_("Remote failure reply: %s"), buf
);
6292 status
->kind
= TARGET_WAITKIND_STOPPED
;
6293 status
->value
.sig
= GDB_SIGNAL_0
;
6295 case 'F': /* File-I/O request. */
6296 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
6297 rs
->ctrlc_pending_p
= 0;
6299 case 'T': case 'S': case 'X': case 'W':
6301 struct stop_reply
*stop_reply
6302 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
6305 event_ptid
= process_stop_reply (stop_reply
, status
);
6308 case 'O': /* Console output. */
6309 remote_console_output (buf
+ 1);
6311 /* The target didn't really stop; keep waiting. */
6312 rs
->waiting_for_stop_reply
= 1;
6316 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
6318 /* Zero length reply means that we tried 'S' or 'C' and the
6319 remote system doesn't support it. */
6320 target_terminal_ours_for_output ();
6322 ("Can't send signals to this remote system. %s not sent.\n",
6323 gdb_signal_to_name (rs
->last_sent_signal
));
6324 rs
->last_sent_signal
= GDB_SIGNAL_0
;
6325 target_terminal_inferior ();
6327 strcpy ((char *) buf
, rs
->last_sent_step
? "s" : "c");
6328 putpkt ((char *) buf
);
6330 /* We just told the target to resume, so a stop reply is in
6332 rs
->waiting_for_stop_reply
= 1;
6335 /* else fallthrough */
6337 warning (_("Invalid remote reply: %s"), buf
);
6339 rs
->waiting_for_stop_reply
= 1;
6343 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
6345 /* Nothing interesting happened. If we're doing a non-blocking
6346 poll, we're done. Otherwise, go back to waiting. */
6347 if (options
& TARGET_WNOHANG
)
6348 return minus_one_ptid
;
6352 else if (status
->kind
!= TARGET_WAITKIND_EXITED
6353 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
6355 if (!ptid_equal (event_ptid
, null_ptid
))
6356 record_currthread (rs
, event_ptid
);
6358 event_ptid
= inferior_ptid
;
6361 /* A process exit. Invalidate our notion of current thread. */
6362 record_currthread (rs
, minus_one_ptid
);
6367 /* Wait until the remote machine stops, then return, storing status in
6368 STATUS just as `wait' would. */
6371 remote_wait (struct target_ops
*ops
,
6372 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
6377 event_ptid
= remote_wait_ns (ptid
, status
, options
);
6379 event_ptid
= remote_wait_as (ptid
, status
, options
);
6381 if (target_is_async_p ())
6383 /* If there are are events left in the queue tell the event loop
6385 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6386 mark_async_event_handler (remote_async_inferior_event_token
);
6392 /* Fetch a single register using a 'p' packet. */
6395 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
6397 struct remote_state
*rs
= get_remote_state ();
6399 char regp
[MAX_REGISTER_SIZE
];
6402 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
6405 if (reg
->pnum
== -1)
6410 p
+= hexnumstr (p
, reg
->pnum
);
6413 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6417 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
6421 case PACKET_UNKNOWN
:
6424 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
6425 gdbarch_register_name (get_regcache_arch (regcache
),
6430 /* If this register is unfetchable, tell the regcache. */
6433 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
6437 /* Otherwise, parse and supply the value. */
6443 error (_("fetch_register_using_p: early buf termination"));
6445 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
6448 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
6452 /* Fetch the registers included in the target's 'g' packet. */
6455 send_g_packet (void)
6457 struct remote_state
*rs
= get_remote_state ();
6460 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
6461 remote_send (&rs
->buf
, &rs
->buf_size
);
6463 /* We can get out of synch in various cases. If the first character
6464 in the buffer is not a hex character, assume that has happened
6465 and try to fetch another packet to read. */
6466 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
6467 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
6468 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
6469 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
6472 fprintf_unfiltered (gdb_stdlog
,
6473 "Bad register packet; fetching a new packet\n");
6474 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6477 buf_len
= strlen (rs
->buf
);
6479 /* Sanity check the received packet. */
6480 if (buf_len
% 2 != 0)
6481 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
6487 process_g_packet (struct regcache
*regcache
)
6489 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
6490 struct remote_state
*rs
= get_remote_state ();
6491 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6496 buf_len
= strlen (rs
->buf
);
6498 /* Further sanity checks, with knowledge of the architecture. */
6499 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
6500 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
6502 /* Save the size of the packet sent to us by the target. It is used
6503 as a heuristic when determining the max size of packets that the
6504 target can safely receive. */
6505 if (rsa
->actual_register_packet_size
== 0)
6506 rsa
->actual_register_packet_size
= buf_len
;
6508 /* If this is smaller than we guessed the 'g' packet would be,
6509 update our records. A 'g' reply that doesn't include a register's
6510 value implies either that the register is not available, or that
6511 the 'p' packet must be used. */
6512 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
6514 rsa
->sizeof_g_packet
= buf_len
/ 2;
6516 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
6518 if (rsa
->regs
[i
].pnum
== -1)
6521 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
6522 rsa
->regs
[i
].in_g_packet
= 0;
6524 rsa
->regs
[i
].in_g_packet
= 1;
6528 regs
= alloca (rsa
->sizeof_g_packet
);
6530 /* Unimplemented registers read as all bits zero. */
6531 memset (regs
, 0, rsa
->sizeof_g_packet
);
6533 /* Reply describes registers byte by byte, each byte encoded as two
6534 hex characters. Suck them all up, then supply them to the
6535 register cacheing/storage mechanism. */
6538 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
6540 if (p
[0] == 0 || p
[1] == 0)
6541 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
6542 internal_error (__FILE__
, __LINE__
,
6543 _("unexpected end of 'g' packet reply"));
6545 if (p
[0] == 'x' && p
[1] == 'x')
6546 regs
[i
] = 0; /* 'x' */
6548 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
6552 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
6554 struct packet_reg
*r
= &rsa
->regs
[i
];
6558 if (r
->offset
* 2 >= strlen (rs
->buf
))
6559 /* This shouldn't happen - we adjusted in_g_packet above. */
6560 internal_error (__FILE__
, __LINE__
,
6561 _("unexpected end of 'g' packet reply"));
6562 else if (rs
->buf
[r
->offset
* 2] == 'x')
6564 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
6565 /* The register isn't available, mark it as such (at
6566 the same time setting the value to zero). */
6567 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
6570 regcache_raw_supply (regcache
, r
->regnum
,
6577 fetch_registers_using_g (struct regcache
*regcache
)
6580 process_g_packet (regcache
);
6583 /* Make the remote selected traceframe match GDB's selected
6587 set_remote_traceframe (void)
6590 struct remote_state
*rs
= get_remote_state ();
6592 if (rs
->remote_traceframe_number
== get_traceframe_number ())
6595 /* Avoid recursion, remote_trace_find calls us again. */
6596 rs
->remote_traceframe_number
= get_traceframe_number ();
6598 newnum
= target_trace_find (tfind_number
,
6599 get_traceframe_number (), 0, 0, NULL
);
6601 /* Should not happen. If it does, all bets are off. */
6602 if (newnum
!= get_traceframe_number ())
6603 warning (_("could not set remote traceframe"));
6607 remote_fetch_registers (struct target_ops
*ops
,
6608 struct regcache
*regcache
, int regnum
)
6610 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6613 set_remote_traceframe ();
6614 set_general_thread (inferior_ptid
);
6618 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
6620 gdb_assert (reg
!= NULL
);
6622 /* If this register might be in the 'g' packet, try that first -
6623 we are likely to read more than one register. If this is the
6624 first 'g' packet, we might be overly optimistic about its
6625 contents, so fall back to 'p'. */
6626 if (reg
->in_g_packet
)
6628 fetch_registers_using_g (regcache
);
6629 if (reg
->in_g_packet
)
6633 if (fetch_register_using_p (regcache
, reg
))
6636 /* This register is not available. */
6637 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
6642 fetch_registers_using_g (regcache
);
6644 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6645 if (!rsa
->regs
[i
].in_g_packet
)
6646 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
6648 /* This register is not available. */
6649 regcache_raw_supply (regcache
, i
, NULL
);
6653 /* Prepare to store registers. Since we may send them all (using a
6654 'G' request), we have to read out the ones we don't want to change
6658 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
6660 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6662 gdb_byte buf
[MAX_REGISTER_SIZE
];
6664 /* Make sure the entire registers array is valid. */
6665 switch (packet_support (PACKET_P
))
6667 case PACKET_DISABLE
:
6668 case PACKET_SUPPORT_UNKNOWN
:
6669 /* Make sure all the necessary registers are cached. */
6670 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6671 if (rsa
->regs
[i
].in_g_packet
)
6672 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
6679 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
6680 packet was not recognized. */
6683 store_register_using_P (const struct regcache
*regcache
,
6684 struct packet_reg
*reg
)
6686 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
6687 struct remote_state
*rs
= get_remote_state ();
6688 /* Try storing a single register. */
6689 char *buf
= rs
->buf
;
6690 gdb_byte regp
[MAX_REGISTER_SIZE
];
6693 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
6696 if (reg
->pnum
== -1)
6699 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
6700 p
= buf
+ strlen (buf
);
6701 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
6702 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
6704 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6706 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
6711 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
6712 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
6713 case PACKET_UNKNOWN
:
6716 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
6720 /* Store register REGNUM, or all registers if REGNUM == -1, from the
6721 contents of the register cache buffer. FIXME: ignores errors. */
6724 store_registers_using_G (const struct regcache
*regcache
)
6726 struct remote_state
*rs
= get_remote_state ();
6727 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6731 /* Extract all the registers in the regcache copying them into a
6736 regs
= alloca (rsa
->sizeof_g_packet
);
6737 memset (regs
, 0, rsa
->sizeof_g_packet
);
6738 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6740 struct packet_reg
*r
= &rsa
->regs
[i
];
6743 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
6747 /* Command describes registers byte by byte,
6748 each byte encoded as two hex characters. */
6751 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
6753 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
6755 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6756 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
6757 error (_("Could not write registers; remote failure reply '%s'"),
6761 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
6762 of the register cache buffer. FIXME: ignores errors. */
6765 remote_store_registers (struct target_ops
*ops
,
6766 struct regcache
*regcache
, int regnum
)
6768 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6771 set_remote_traceframe ();
6772 set_general_thread (inferior_ptid
);
6776 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
6778 gdb_assert (reg
!= NULL
);
6780 /* Always prefer to store registers using the 'P' packet if
6781 possible; we often change only a small number of registers.
6782 Sometimes we change a larger number; we'd need help from a
6783 higher layer to know to use 'G'. */
6784 if (store_register_using_P (regcache
, reg
))
6787 /* For now, don't complain if we have no way to write the
6788 register. GDB loses track of unavailable registers too
6789 easily. Some day, this may be an error. We don't have
6790 any way to read the register, either... */
6791 if (!reg
->in_g_packet
)
6794 store_registers_using_G (regcache
);
6798 store_registers_using_G (regcache
);
6800 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6801 if (!rsa
->regs
[i
].in_g_packet
)
6802 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
6803 /* See above for why we do not issue an error here. */
6808 /* Return the number of hex digits in num. */
6811 hexnumlen (ULONGEST num
)
6815 for (i
= 0; num
!= 0; i
++)
6821 /* Set BUF to the minimum number of hex digits representing NUM. */
6824 hexnumstr (char *buf
, ULONGEST num
)
6826 int len
= hexnumlen (num
);
6828 return hexnumnstr (buf
, num
, len
);
6832 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
6835 hexnumnstr (char *buf
, ULONGEST num
, int width
)
6841 for (i
= width
- 1; i
>= 0; i
--)
6843 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
6850 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
6853 remote_address_masked (CORE_ADDR addr
)
6855 unsigned int address_size
= remote_address_size
;
6857 /* If "remoteaddresssize" was not set, default to target address size. */
6859 address_size
= gdbarch_addr_bit (target_gdbarch ());
6861 if (address_size
> 0
6862 && address_size
< (sizeof (ULONGEST
) * 8))
6864 /* Only create a mask when that mask can safely be constructed
6865 in a ULONGEST variable. */
6868 mask
= (mask
<< address_size
) - 1;
6874 /* Determine whether the remote target supports binary downloading.
6875 This is accomplished by sending a no-op memory write of zero length
6876 to the target at the specified address. It does not suffice to send
6877 the whole packet, since many stubs strip the eighth bit and
6878 subsequently compute a wrong checksum, which causes real havoc with
6881 NOTE: This can still lose if the serial line is not eight-bit
6882 clean. In cases like this, the user should clear "remote
6886 check_binary_download (CORE_ADDR addr
)
6888 struct remote_state
*rs
= get_remote_state ();
6890 switch (packet_support (PACKET_X
))
6892 case PACKET_DISABLE
:
6896 case PACKET_SUPPORT_UNKNOWN
:
6902 p
+= hexnumstr (p
, (ULONGEST
) addr
);
6904 p
+= hexnumstr (p
, (ULONGEST
) 0);
6908 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
6909 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6911 if (rs
->buf
[0] == '\0')
6914 fprintf_unfiltered (gdb_stdlog
,
6915 "binary downloading NOT "
6916 "supported by target\n");
6917 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
6922 fprintf_unfiltered (gdb_stdlog
,
6923 "binary downloading supported by target\n");
6924 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
6931 /* Helper function to resize the payload in order to try to get a good
6932 alignment. We try to write an amount of data such that the next write will
6933 start on an address aligned on REMOTE_ALIGN_WRITES. */
6936 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
6938 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
6941 /* Write memory data directly to the remote machine.
6942 This does not inform the data cache; the data cache uses this.
6943 HEADER is the starting part of the packet.
6944 MEMADDR is the address in the remote memory space.
6945 MYADDR is the address of the buffer in our space.
6946 LEN_UNITS is the number of addressable units to write.
6947 UNIT_SIZE is the length in bytes of an addressable unit.
6948 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
6949 should send data as binary ('X'), or hex-encoded ('M').
6951 The function creates packet of the form
6952 <HEADER><ADDRESS>,<LENGTH>:<DATA>
6954 where encoding of <DATA> is terminated by PACKET_FORMAT.
6956 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
6959 Return the transferred status, error or OK (an
6960 'enum target_xfer_status' value). Save the number of addressable units
6961 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
6963 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
6964 exchange between gdb and the stub could look like (?? in place of the
6970 -> $M1000,3:eeeeffffeeee#??
6974 <- eeeeffffeeeedddd */
6976 static enum target_xfer_status
6977 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
6978 const gdb_byte
*myaddr
, ULONGEST len_units
,
6979 int unit_size
, ULONGEST
*xfered_len_units
,
6980 char packet_format
, int use_length
)
6982 struct remote_state
*rs
= get_remote_state ();
6988 int payload_capacity_bytes
;
6989 int payload_length_bytes
;
6991 if (packet_format
!= 'X' && packet_format
!= 'M')
6992 internal_error (__FILE__
, __LINE__
,
6993 _("remote_write_bytes_aux: bad packet format"));
6996 return TARGET_XFER_EOF
;
6998 payload_capacity_bytes
= get_memory_write_packet_size ();
7000 /* The packet buffer will be large enough for the payload;
7001 get_memory_packet_size ensures this. */
7004 /* Compute the size of the actual payload by subtracting out the
7005 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
7007 payload_capacity_bytes
-= strlen ("$,:#NN");
7009 /* The comma won't be used. */
7010 payload_capacity_bytes
+= 1;
7011 payload_capacity_bytes
-= strlen (header
);
7012 payload_capacity_bytes
-= hexnumlen (memaddr
);
7014 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
7016 strcat (rs
->buf
, header
);
7017 p
= rs
->buf
+ strlen (header
);
7019 /* Compute a best guess of the number of bytes actually transfered. */
7020 if (packet_format
== 'X')
7022 /* Best guess at number of bytes that will fit. */
7023 todo_units
= min (len_units
, payload_capacity_bytes
/ unit_size
);
7025 payload_capacity_bytes
-= hexnumlen (todo_units
);
7026 todo_units
= min (todo_units
, payload_capacity_bytes
/ unit_size
);
7030 /* Number of bytes that will fit. */
7031 todo_units
= min (len_units
, (payload_capacity_bytes
/ unit_size
) / 2);
7033 payload_capacity_bytes
-= hexnumlen (todo_units
);
7034 todo_units
= min (todo_units
, (payload_capacity_bytes
/ unit_size
) / 2);
7037 if (todo_units
<= 0)
7038 internal_error (__FILE__
, __LINE__
,
7039 _("minimum packet size too small to write data"));
7041 /* If we already need another packet, then try to align the end
7042 of this packet to a useful boundary. */
7043 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
7044 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
7046 /* Append "<memaddr>". */
7047 memaddr
= remote_address_masked (memaddr
);
7048 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
7055 /* Append the length and retain its location and size. It may need to be
7056 adjusted once the packet body has been created. */
7058 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
7066 /* Append the packet body. */
7067 if (packet_format
== 'X')
7069 /* Binary mode. Send target system values byte by byte, in
7070 increasing byte addresses. Only escape certain critical
7072 payload_length_bytes
=
7073 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
7074 &units_written
, payload_capacity_bytes
);
7076 /* If not all TODO units fit, then we'll need another packet. Make
7077 a second try to keep the end of the packet aligned. Don't do
7078 this if the packet is tiny. */
7079 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
7083 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
7085 if (new_todo_units
!= units_written
)
7086 payload_length_bytes
=
7087 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
7088 (gdb_byte
*) p
, &units_written
,
7089 payload_capacity_bytes
);
7092 p
+= payload_length_bytes
;
7093 if (use_length
&& units_written
< todo_units
)
7095 /* Escape chars have filled up the buffer prematurely,
7096 and we have actually sent fewer units than planned.
7097 Fix-up the length field of the packet. Use the same
7098 number of characters as before. */
7099 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
7101 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
7106 /* Normal mode: Send target system values byte by byte, in
7107 increasing byte addresses. Each byte is encoded as a two hex
7109 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
7110 units_written
= todo_units
;
7113 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
7114 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7116 if (rs
->buf
[0] == 'E')
7117 return TARGET_XFER_E_IO
;
7119 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
7120 send fewer units than we'd planned. */
7121 *xfered_len_units
= (ULONGEST
) units_written
;
7122 return TARGET_XFER_OK
;
7125 /* Write memory data directly to the remote machine.
7126 This does not inform the data cache; the data cache uses this.
7127 MEMADDR is the address in the remote memory space.
7128 MYADDR is the address of the buffer in our space.
7129 LEN is the number of bytes.
7131 Return the transferred status, error or OK (an
7132 'enum target_xfer_status' value). Save the number of bytes
7133 transferred in *XFERED_LEN. Only transfer a single packet. */
7135 static enum target_xfer_status
7136 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
7137 int unit_size
, ULONGEST
*xfered_len
)
7139 char *packet_format
= 0;
7141 /* Check whether the target supports binary download. */
7142 check_binary_download (memaddr
);
7144 switch (packet_support (PACKET_X
))
7147 packet_format
= "X";
7149 case PACKET_DISABLE
:
7150 packet_format
= "M";
7152 case PACKET_SUPPORT_UNKNOWN
:
7153 internal_error (__FILE__
, __LINE__
,
7154 _("remote_write_bytes: bad internal state"));
7156 internal_error (__FILE__
, __LINE__
, _("bad switch"));
7159 return remote_write_bytes_aux (packet_format
,
7160 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
7161 packet_format
[0], 1);
7164 /* Read memory data directly from the remote machine.
7165 This does not use the data cache; the data cache uses this.
7166 MEMADDR is the address in the remote memory space.
7167 MYADDR is the address of the buffer in our space.
7168 LEN_UNITS is the number of addressable memory units to read..
7169 UNIT_SIZE is the length in bytes of an addressable unit.
7171 Return the transferred status, error or OK (an
7172 'enum target_xfer_status' value). Save the number of bytes
7173 transferred in *XFERED_LEN_UNITS.
7175 See the comment of remote_write_bytes_aux for an example of
7176 memory read/write exchange between gdb and the stub. */
7178 static enum target_xfer_status
7179 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
7180 int unit_size
, ULONGEST
*xfered_len_units
)
7182 struct remote_state
*rs
= get_remote_state ();
7183 int buf_size_bytes
; /* Max size of packet output buffer. */
7188 buf_size_bytes
= get_memory_read_packet_size ();
7189 /* The packet buffer will be large enough for the payload;
7190 get_memory_packet_size ensures this. */
7192 /* Number of units that will fit. */
7193 todo_units
= min (len_units
, (buf_size_bytes
/ unit_size
) / 2);
7195 /* Construct "m"<memaddr>","<len>". */
7196 memaddr
= remote_address_masked (memaddr
);
7199 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
7201 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
7204 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7205 if (rs
->buf
[0] == 'E'
7206 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
7207 && rs
->buf
[3] == '\0')
7208 return TARGET_XFER_E_IO
;
7209 /* Reply describes memory byte by byte, each byte encoded as two hex
7212 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
7213 /* Return what we have. Let higher layers handle partial reads. */
7214 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
7215 return TARGET_XFER_OK
;
7218 /* Using the set of read-only target sections of remote, read live
7221 For interface/parameters/return description see target.h,
7224 static enum target_xfer_status
7225 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
7226 ULONGEST memaddr
, ULONGEST len
,
7227 int unit_size
, ULONGEST
*xfered_len
)
7229 struct target_section
*secp
;
7230 struct target_section_table
*table
;
7232 secp
= target_section_by_addr (ops
, memaddr
);
7234 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
7235 secp
->the_bfd_section
)
7238 struct target_section
*p
;
7239 ULONGEST memend
= memaddr
+ len
;
7241 table
= target_get_section_table (ops
);
7243 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
7245 if (memaddr
>= p
->addr
)
7247 if (memend
<= p
->endaddr
)
7249 /* Entire transfer is within this section. */
7250 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
7253 else if (memaddr
>= p
->endaddr
)
7255 /* This section ends before the transfer starts. */
7260 /* This section overlaps the transfer. Just do half. */
7261 len
= p
->endaddr
- memaddr
;
7262 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
7269 return TARGET_XFER_EOF
;
7272 /* Similar to remote_read_bytes_1, but it reads from the remote stub
7273 first if the requested memory is unavailable in traceframe.
7274 Otherwise, fall back to remote_read_bytes_1. */
7276 static enum target_xfer_status
7277 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
7278 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
7279 ULONGEST
*xfered_len
)
7282 return TARGET_XFER_EOF
;
7284 if (get_traceframe_number () != -1)
7286 VEC(mem_range_s
) *available
;
7288 /* If we fail to get the set of available memory, then the
7289 target does not support querying traceframe info, and so we
7290 attempt reading from the traceframe anyway (assuming the
7291 target implements the old QTro packet then). */
7292 if (traceframe_available_memory (&available
, memaddr
, len
))
7294 struct cleanup
*old_chain
;
7296 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
7298 if (VEC_empty (mem_range_s
, available
)
7299 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
7301 enum target_xfer_status res
;
7303 /* Don't read into the traceframe's available
7305 if (!VEC_empty (mem_range_s
, available
))
7307 LONGEST oldlen
= len
;
7309 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
7310 gdb_assert (len
<= oldlen
);
7313 do_cleanups (old_chain
);
7315 /* This goes through the topmost target again. */
7316 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
7317 len
, unit_size
, xfered_len
);
7318 if (res
== TARGET_XFER_OK
)
7319 return TARGET_XFER_OK
;
7322 /* No use trying further, we know some memory starting
7323 at MEMADDR isn't available. */
7325 return TARGET_XFER_UNAVAILABLE
;
7329 /* Don't try to read more than how much is available, in
7330 case the target implements the deprecated QTro packet to
7331 cater for older GDBs (the target's knowledge of read-only
7332 sections may be outdated by now). */
7333 len
= VEC_index (mem_range_s
, available
, 0)->length
;
7335 do_cleanups (old_chain
);
7339 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
7344 /* Sends a packet with content determined by the printf format string
7345 FORMAT and the remaining arguments, then gets the reply. Returns
7346 whether the packet was a success, a failure, or unknown. */
7348 static enum packet_result
remote_send_printf (const char *format
, ...)
7349 ATTRIBUTE_PRINTF (1, 2);
7351 static enum packet_result
7352 remote_send_printf (const char *format
, ...)
7354 struct remote_state
*rs
= get_remote_state ();
7355 int max_size
= get_remote_packet_size ();
7358 va_start (ap
, format
);
7361 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
7362 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
7364 if (putpkt (rs
->buf
) < 0)
7365 error (_("Communication problem with target."));
7368 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7370 return packet_check_result (rs
->buf
);
7374 restore_remote_timeout (void *p
)
7376 int value
= *(int *)p
;
7378 remote_timeout
= value
;
7381 /* Flash writing can take quite some time. We'll set
7382 effectively infinite timeout for flash operations.
7383 In future, we'll need to decide on a better approach. */
7384 static const int remote_flash_timeout
= 1000;
7387 remote_flash_erase (struct target_ops
*ops
,
7388 ULONGEST address
, LONGEST length
)
7390 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
7391 int saved_remote_timeout
= remote_timeout
;
7392 enum packet_result ret
;
7393 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
7394 &saved_remote_timeout
);
7396 remote_timeout
= remote_flash_timeout
;
7398 ret
= remote_send_printf ("vFlashErase:%s,%s",
7399 phex (address
, addr_size
),
7403 case PACKET_UNKNOWN
:
7404 error (_("Remote target does not support flash erase"));
7406 error (_("Error erasing flash with vFlashErase packet"));
7411 do_cleanups (back_to
);
7414 static enum target_xfer_status
7415 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
7416 ULONGEST length
, ULONGEST
*xfered_len
,
7417 const gdb_byte
*data
)
7419 int saved_remote_timeout
= remote_timeout
;
7420 enum target_xfer_status ret
;
7421 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
7422 &saved_remote_timeout
);
7424 remote_timeout
= remote_flash_timeout
;
7425 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
7427 do_cleanups (back_to
);
7433 remote_flash_done (struct target_ops
*ops
)
7435 int saved_remote_timeout
= remote_timeout
;
7437 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
7438 &saved_remote_timeout
);
7440 remote_timeout
= remote_flash_timeout
;
7441 ret
= remote_send_printf ("vFlashDone");
7442 do_cleanups (back_to
);
7446 case PACKET_UNKNOWN
:
7447 error (_("Remote target does not support vFlashDone"));
7449 error (_("Error finishing flash operation"));
7456 remote_files_info (struct target_ops
*ignore
)
7458 puts_filtered ("Debugging a target over a serial line.\n");
7461 /* Stuff for dealing with the packets which are part of this protocol.
7462 See comment at top of file for details. */
7464 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
7465 error to higher layers. Called when a serial error is detected.
7466 The exception message is STRING, followed by a colon and a blank,
7467 the system error message for errno at function entry and final dot
7468 for output compatibility with throw_perror_with_name. */
7471 unpush_and_perror (const char *string
)
7473 int saved_errno
= errno
;
7475 remote_unpush_target ();
7476 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
7477 safe_strerror (saved_errno
));
7480 /* Read a single character from the remote end. */
7483 readchar (int timeout
)
7486 struct remote_state
*rs
= get_remote_state ();
7488 ch
= serial_readchar (rs
->remote_desc
, timeout
);
7493 switch ((enum serial_rc
) ch
)
7496 remote_unpush_target ();
7497 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
7500 unpush_and_perror (_("Remote communication error. "
7501 "Target disconnected."));
7503 case SERIAL_TIMEOUT
:
7509 /* Wrapper for serial_write that closes the target and throws if
7513 remote_serial_write (const char *str
, int len
)
7515 struct remote_state
*rs
= get_remote_state ();
7517 if (serial_write (rs
->remote_desc
, str
, len
))
7519 unpush_and_perror (_("Remote communication error. "
7520 "Target disconnected."));
7524 /* Send the command in *BUF to the remote machine, and read the reply
7525 into *BUF. Report an error if we get an error reply. Resize
7526 *BUF using xrealloc if necessary to hold the result, and update
7530 remote_send (char **buf
,
7534 getpkt (buf
, sizeof_buf
, 0);
7536 if ((*buf
)[0] == 'E')
7537 error (_("Remote failure reply: %s"), *buf
);
7540 /* Return a pointer to an xmalloc'ed string representing an escaped
7541 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t,
7542 etc. The caller is responsible for releasing the returned
7546 escape_buffer (const char *buf
, int n
)
7548 struct cleanup
*old_chain
;
7549 struct ui_file
*stb
;
7552 stb
= mem_fileopen ();
7553 old_chain
= make_cleanup_ui_file_delete (stb
);
7555 fputstrn_unfiltered (buf
, n
, '\\', stb
);
7556 str
= ui_file_xstrdup (stb
, NULL
);
7557 do_cleanups (old_chain
);
7561 /* Display a null-terminated packet on stdout, for debugging, using C
7565 print_packet (const char *buf
)
7567 puts_filtered ("\"");
7568 fputstr_filtered (buf
, '"', gdb_stdout
);
7569 puts_filtered ("\"");
7573 putpkt (const char *buf
)
7575 return putpkt_binary (buf
, strlen (buf
));
7578 /* Send a packet to the remote machine, with error checking. The data
7579 of the packet is in BUF. The string in BUF can be at most
7580 get_remote_packet_size () - 5 to account for the $, # and checksum,
7581 and for a possible /0 if we are debugging (remote_debug) and want
7582 to print the sent packet as a string. */
7585 putpkt_binary (const char *buf
, int cnt
)
7587 struct remote_state
*rs
= get_remote_state ();
7589 unsigned char csum
= 0;
7590 char *buf2
= alloca (cnt
+ 6);
7597 /* Catch cases like trying to read memory or listing threads while
7598 we're waiting for a stop reply. The remote server wouldn't be
7599 ready to handle this request, so we'd hang and timeout. We don't
7600 have to worry about this in synchronous mode, because in that
7601 case it's not possible to issue a command while the target is
7602 running. This is not a problem in non-stop mode, because in that
7603 case, the stub is always ready to process serial input. */
7604 if (!non_stop
&& target_is_async_p () && rs
->waiting_for_stop_reply
)
7606 error (_("Cannot execute this command while the target is running.\n"
7607 "Use the \"interrupt\" command to stop the target\n"
7608 "and then try again."));
7611 /* We're sending out a new packet. Make sure we don't look at a
7612 stale cached response. */
7613 rs
->cached_wait_status
= 0;
7615 /* Copy the packet into buffer BUF2, encapsulating it
7616 and giving it a checksum. */
7621 for (i
= 0; i
< cnt
; i
++)
7627 *p
++ = tohex ((csum
>> 4) & 0xf);
7628 *p
++ = tohex (csum
& 0xf);
7630 /* Send it over and over until we get a positive ack. */
7634 int started_error_output
= 0;
7638 struct cleanup
*old_chain
;
7642 str
= escape_buffer (buf2
, p
- buf2
);
7643 old_chain
= make_cleanup (xfree
, str
);
7644 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s...", str
);
7645 gdb_flush (gdb_stdlog
);
7646 do_cleanups (old_chain
);
7648 remote_serial_write (buf2
, p
- buf2
);
7650 /* If this is a no acks version of the remote protocol, send the
7651 packet and move on. */
7655 /* Read until either a timeout occurs (-2) or '+' is read.
7656 Handle any notification that arrives in the mean time. */
7659 ch
= readchar (remote_timeout
);
7667 case SERIAL_TIMEOUT
:
7670 if (started_error_output
)
7672 putchar_unfiltered ('\n');
7673 started_error_output
= 0;
7682 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
7686 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
7688 case SERIAL_TIMEOUT
:
7692 break; /* Retransmit buffer. */
7696 fprintf_unfiltered (gdb_stdlog
,
7697 "Packet instead of Ack, ignoring it\n");
7698 /* It's probably an old response sent because an ACK
7699 was lost. Gobble up the packet and ack it so it
7700 doesn't get retransmitted when we resend this
7703 remote_serial_write ("+", 1);
7704 continue; /* Now, go look for +. */
7711 /* If we got a notification, handle it, and go back to looking
7713 /* We've found the start of a notification. Now
7714 collect the data. */
7715 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
7720 struct cleanup
*old_chain
;
7723 str
= escape_buffer (rs
->buf
, val
);
7724 old_chain
= make_cleanup (xfree
, str
);
7725 fprintf_unfiltered (gdb_stdlog
,
7726 " Notification received: %s\n",
7728 do_cleanups (old_chain
);
7730 handle_notification (rs
->notif_state
, rs
->buf
);
7731 /* We're in sync now, rewait for the ack. */
7738 if (!started_error_output
)
7740 started_error_output
= 1;
7741 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
7743 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
7744 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
7753 if (!started_error_output
)
7755 started_error_output
= 1;
7756 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
7758 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
7762 break; /* Here to retransmit. */
7766 /* This is wrong. If doing a long backtrace, the user should be
7767 able to get out next time we call QUIT, without anything as
7768 violent as interrupt_query. If we want to provide a way out of
7769 here without getting to the next QUIT, it should be based on
7770 hitting ^C twice as in remote_wait. */
7781 /* Come here after finding the start of a frame when we expected an
7782 ack. Do our best to discard the rest of this packet. */
7791 c
= readchar (remote_timeout
);
7794 case SERIAL_TIMEOUT
:
7795 /* Nothing we can do. */
7798 /* Discard the two bytes of checksum and stop. */
7799 c
= readchar (remote_timeout
);
7801 c
= readchar (remote_timeout
);
7804 case '*': /* Run length encoding. */
7805 /* Discard the repeat count. */
7806 c
= readchar (remote_timeout
);
7811 /* A regular character. */
7817 /* Come here after finding the start of the frame. Collect the rest
7818 into *BUF, verifying the checksum, length, and handling run-length
7819 compression. NUL terminate the buffer. If there is not enough room,
7820 expand *BUF using xrealloc.
7822 Returns -1 on error, number of characters in buffer (ignoring the
7823 trailing NULL) on success. (could be extended to return one of the
7824 SERIAL status indications). */
7827 read_frame (char **buf_p
,
7834 struct remote_state
*rs
= get_remote_state ();
7841 c
= readchar (remote_timeout
);
7844 case SERIAL_TIMEOUT
:
7846 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
7850 fputs_filtered ("Saw new packet start in middle of old one\n",
7852 return -1; /* Start a new packet, count retries. */
7855 unsigned char pktcsum
;
7861 check_0
= readchar (remote_timeout
);
7863 check_1
= readchar (remote_timeout
);
7865 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
7868 fputs_filtered ("Timeout in checksum, retrying\n",
7872 else if (check_0
< 0 || check_1
< 0)
7875 fputs_filtered ("Communication error in checksum\n",
7880 /* Don't recompute the checksum; with no ack packets we
7881 don't have any way to indicate a packet retransmission
7886 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
7887 if (csum
== pktcsum
)
7892 struct cleanup
*old_chain
;
7895 str
= escape_buffer (buf
, bc
);
7896 old_chain
= make_cleanup (xfree
, str
);
7897 fprintf_unfiltered (gdb_stdlog
,
7898 "Bad checksum, sentsum=0x%x, "
7899 "csum=0x%x, buf=%s\n",
7900 pktcsum
, csum
, str
);
7901 do_cleanups (old_chain
);
7903 /* Number of characters in buffer ignoring trailing
7907 case '*': /* Run length encoding. */
7912 c
= readchar (remote_timeout
);
7914 repeat
= c
- ' ' + 3; /* Compute repeat count. */
7916 /* The character before ``*'' is repeated. */
7918 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
7920 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
7922 /* Make some more room in the buffer. */
7923 *sizeof_buf
+= repeat
;
7924 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
7928 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
7934 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
7938 if (bc
>= *sizeof_buf
- 1)
7940 /* Make some more room in the buffer. */
7942 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
7953 /* Read a packet from the remote machine, with error checking, and
7954 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
7955 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
7956 rather than timing out; this is used (in synchronous mode) to wait
7957 for a target that is is executing user code to stop. */
7958 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
7959 don't have to change all the calls to getpkt to deal with the
7960 return value, because at the moment I don't know what the right
7961 thing to do it for those. */
7969 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
7973 /* Read a packet from the remote machine, with error checking, and
7974 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
7975 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
7976 rather than timing out; this is used (in synchronous mode) to wait
7977 for a target that is is executing user code to stop. If FOREVER ==
7978 0, this function is allowed to time out gracefully and return an
7979 indication of this to the caller. Otherwise return the number of
7980 bytes read. If EXPECTING_NOTIF, consider receiving a notification
7981 enough reason to return to the caller. *IS_NOTIF is an output
7982 boolean that indicates whether *BUF holds a notification or not
7983 (a regular packet). */
7986 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
7987 int expecting_notif
, int *is_notif
)
7989 struct remote_state
*rs
= get_remote_state ();
7995 /* We're reading a new response. Make sure we don't look at a
7996 previously cached response. */
7997 rs
->cached_wait_status
= 0;
7999 strcpy (*buf
, "timeout");
8002 timeout
= watchdog
> 0 ? watchdog
: -1;
8003 else if (expecting_notif
)
8004 timeout
= 0; /* There should already be a char in the buffer. If
8007 timeout
= remote_timeout
;
8011 /* Process any number of notifications, and then return when
8015 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
8017 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
8019 /* This can loop forever if the remote side sends us
8020 characters continuously, but if it pauses, we'll get
8021 SERIAL_TIMEOUT from readchar because of timeout. Then
8022 we'll count that as a retry.
8024 Note that even when forever is set, we will only wait
8025 forever prior to the start of a packet. After that, we
8026 expect characters to arrive at a brisk pace. They should
8027 show up within remote_timeout intervals. */
8029 c
= readchar (timeout
);
8030 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
8032 if (c
== SERIAL_TIMEOUT
)
8034 if (expecting_notif
)
8035 return -1; /* Don't complain, it's normal to not get
8036 anything in this case. */
8038 if (forever
) /* Watchdog went off? Kill the target. */
8041 remote_unpush_target ();
8042 throw_error (TARGET_CLOSE_ERROR
,
8043 _("Watchdog timeout has expired. "
8044 "Target detached."));
8047 fputs_filtered ("Timed out.\n", gdb_stdlog
);
8051 /* We've found the start of a packet or notification.
8052 Now collect the data. */
8053 val
= read_frame (buf
, sizeof_buf
);
8058 remote_serial_write ("-", 1);
8061 if (tries
> MAX_TRIES
)
8063 /* We have tried hard enough, and just can't receive the
8064 packet/notification. Give up. */
8065 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
8067 /* Skip the ack char if we're in no-ack mode. */
8068 if (!rs
->noack_mode
)
8069 remote_serial_write ("+", 1);
8073 /* If we got an ordinary packet, return that to our caller. */
8078 struct cleanup
*old_chain
;
8081 str
= escape_buffer (*buf
, val
);
8082 old_chain
= make_cleanup (xfree
, str
);
8083 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s\n", str
);
8084 do_cleanups (old_chain
);
8087 /* Skip the ack char if we're in no-ack mode. */
8088 if (!rs
->noack_mode
)
8089 remote_serial_write ("+", 1);
8090 if (is_notif
!= NULL
)
8095 /* If we got a notification, handle it, and go back to looking
8099 gdb_assert (c
== '%');
8103 struct cleanup
*old_chain
;
8106 str
= escape_buffer (*buf
, val
);
8107 old_chain
= make_cleanup (xfree
, str
);
8108 fprintf_unfiltered (gdb_stdlog
,
8109 " Notification received: %s\n",
8111 do_cleanups (old_chain
);
8113 if (is_notif
!= NULL
)
8116 handle_notification (rs
->notif_state
, *buf
);
8118 /* Notifications require no acknowledgement. */
8120 if (expecting_notif
)
8127 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
8129 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
8133 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
8136 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
8140 /* Check whether EVENT is a fork event for the process specified
8141 by the pid passed in DATA, and if it is, kill the fork child. */
8144 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
8145 QUEUE_ITER (stop_reply_p
) *iter
,
8149 struct queue_iter_param
*param
= data
;
8150 int parent_pid
= *(int *) param
->input
;
8152 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
8154 struct remote_state
*rs
= get_remote_state ();
8155 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
8158 res
= remote_vkill (child_pid
, rs
);
8160 error (_("Can't kill fork child process %d"), child_pid
);
8166 /* Kill any new fork children of process PID that haven't been
8167 processed by follow_fork. */
8170 kill_new_fork_children (int pid
, struct remote_state
*rs
)
8172 struct thread_info
*thread
;
8173 struct notif_client
*notif
= ¬if_client_stop
;
8174 struct queue_iter_param param
;
8176 /* Kill the fork child threads of any threads in process PID
8177 that are stopped at a fork event. */
8178 ALL_NON_EXITED_THREADS (thread
)
8180 struct target_waitstatus
*ws
= &thread
->pending_follow
;
8182 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
8184 struct remote_state
*rs
= get_remote_state ();
8185 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
8188 res
= remote_vkill (child_pid
, rs
);
8190 error (_("Can't kill fork child process %d"), child_pid
);
8194 /* Check for any pending fork events (not reported or processed yet)
8195 in process PID and kill those fork child threads as well. */
8196 remote_notif_get_pending_events (notif
);
8198 param
.output
= NULL
;
8199 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
8200 kill_child_of_pending_fork
, ¶m
);
8205 remote_kill (struct target_ops
*ops
)
8208 /* Catch errors so the user can quit from gdb even when we
8209 aren't on speaking terms with the remote system. */
8214 CATCH (ex
, RETURN_MASK_ERROR
)
8216 if (ex
.error
== TARGET_CLOSE_ERROR
)
8218 /* If we got an (EOF) error that caused the target
8219 to go away, then we're done, that's what we wanted.
8220 "k" is susceptible to cause a premature EOF, given
8221 that the remote server isn't actually required to
8222 reply to "k", and it can happen that it doesn't
8223 even get to reply ACK to the "k". */
8227 /* Otherwise, something went wrong. We didn't actually kill
8228 the target. Just propagate the exception, and let the
8229 user or higher layers decide what to do. */
8230 throw_exception (ex
);
8234 /* We've killed the remote end, we get to mourn it. Since this is
8235 target remote, single-process, mourning the inferior also
8236 unpushes remote_ops. */
8237 target_mourn_inferior ();
8241 remote_vkill (int pid
, struct remote_state
*rs
)
8243 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
8246 /* Tell the remote target to detach. */
8247 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
8249 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8251 switch (packet_ok (rs
->buf
,
8252 &remote_protocol_packets
[PACKET_vKill
]))
8258 case PACKET_UNKNOWN
:
8261 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8266 extended_remote_kill (struct target_ops
*ops
)
8269 int pid
= ptid_get_pid (inferior_ptid
);
8270 struct remote_state
*rs
= get_remote_state ();
8272 /* If we're stopped while forking and we haven't followed yet, kill the
8273 child task. We need to do this before killing the parent task
8274 because if this is a vfork then the parent will be sleeping. */
8275 kill_new_fork_children (pid
, rs
);
8277 res
= remote_vkill (pid
, rs
);
8278 if (res
== -1 && !(rs
->extended
&& remote_multi_process_p (rs
)))
8280 /* Don't try 'k' on a multi-process aware stub -- it has no way
8281 to specify the pid. */
8285 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8286 if (rs
->buf
[0] != 'O' || rs
->buf
[0] != 'K')
8289 /* Don't wait for it to die. I'm not really sure it matters whether
8290 we do or not. For the existing stubs, kill is a noop. */
8296 error (_("Can't kill process"));
8298 target_mourn_inferior ();
8302 remote_mourn (struct target_ops
*target
)
8304 unpush_target (target
);
8306 /* remote_close takes care of doing most of the clean up. */
8307 generic_mourn_inferior ();
8311 extended_remote_mourn (struct target_ops
*target
)
8313 struct remote_state
*rs
= get_remote_state ();
8315 /* In case we got here due to an error, but we're going to stay
8317 rs
->waiting_for_stop_reply
= 0;
8319 /* If the current general thread belonged to the process we just
8320 detached from or has exited, the remote side current general
8321 thread becomes undefined. Considering a case like this:
8323 - We just got here due to a detach.
8324 - The process that we're detaching from happens to immediately
8325 report a global breakpoint being hit in non-stop mode, in the
8326 same thread we had selected before.
8327 - GDB attaches to this process again.
8328 - This event happens to be the next event we handle.
8330 GDB would consider that the current general thread didn't need to
8331 be set on the stub side (with Hg), since for all it knew,
8332 GENERAL_THREAD hadn't changed.
8334 Notice that although in all-stop mode, the remote server always
8335 sets the current thread to the thread reporting the stop event,
8336 that doesn't happen in non-stop mode; in non-stop, the stub *must
8337 not* change the current thread when reporting a breakpoint hit,
8338 due to the decoupling of event reporting and event handling.
8340 To keep things simple, we always invalidate our notion of the
8342 record_currthread (rs
, minus_one_ptid
);
8344 /* Unlike "target remote", we do not want to unpush the target; then
8345 the next time the user says "run", we won't be connected. */
8347 /* Call common code to mark the inferior as not running. */
8348 generic_mourn_inferior ();
8350 if (!have_inferiors ())
8352 if (!remote_multi_process_p (rs
))
8354 /* Check whether the target is running now - some remote stubs
8355 automatically restart after kill. */
8357 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8359 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
8361 /* Assume that the target has been restarted. Set
8362 inferior_ptid so that bits of core GDB realizes
8363 there's something here, e.g., so that the user can
8364 say "kill" again. */
8365 inferior_ptid
= magic_null_ptid
;
8372 extended_remote_supports_disable_randomization (struct target_ops
*self
)
8374 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
8378 extended_remote_disable_randomization (int val
)
8380 struct remote_state
*rs
= get_remote_state ();
8383 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
8386 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
8388 error (_("Target does not support QDisableRandomization."));
8389 if (strcmp (reply
, "OK") != 0)
8390 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
8394 extended_remote_run (char *args
)
8396 struct remote_state
*rs
= get_remote_state ();
8399 /* If the user has disabled vRun support, or we have detected that
8400 support is not available, do not try it. */
8401 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
8404 strcpy (rs
->buf
, "vRun;");
8405 len
= strlen (rs
->buf
);
8407 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
8408 error (_("Remote file name too long for run packet"));
8409 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
8410 strlen (remote_exec_file
));
8412 gdb_assert (args
!= NULL
);
8415 struct cleanup
*back_to
;
8419 argv
= gdb_buildargv (args
);
8420 back_to
= make_cleanup_freeargv (argv
);
8421 for (i
= 0; argv
[i
] != NULL
; i
++)
8423 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
8424 error (_("Argument list too long for run packet"));
8425 rs
->buf
[len
++] = ';';
8426 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
8429 do_cleanups (back_to
);
8432 rs
->buf
[len
++] = '\0';
8435 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8437 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
8440 /* We have a wait response. All is well. */
8442 case PACKET_UNKNOWN
:
8445 if (remote_exec_file
[0] == '\0')
8446 error (_("Running the default executable on the remote target failed; "
8447 "try \"set remote exec-file\"?"));
8449 error (_("Running \"%s\" on the remote target failed"),
8452 gdb_assert_not_reached (_("bad switch"));
8456 /* In the extended protocol we want to be able to do things like
8457 "run" and have them basically work as expected. So we need
8458 a special create_inferior function. We support changing the
8459 executable file and the command line arguments, but not the
8463 extended_remote_create_inferior (struct target_ops
*ops
,
8464 char *exec_file
, char *args
,
8465 char **env
, int from_tty
)
8469 struct remote_state
*rs
= get_remote_state ();
8471 /* If running asynchronously, register the target file descriptor
8472 with the event loop. */
8473 if (target_can_async_p ())
8476 /* Disable address space randomization if requested (and supported). */
8477 if (extended_remote_supports_disable_randomization (ops
))
8478 extended_remote_disable_randomization (disable_randomization
);
8480 /* Now restart the remote server. */
8481 run_worked
= extended_remote_run (args
) != -1;
8484 /* vRun was not supported. Fail if we need it to do what the
8486 if (remote_exec_file
[0])
8487 error (_("Remote target does not support \"set remote exec-file\""));
8489 error (_("Remote target does not support \"set args\" or run <ARGS>"));
8491 /* Fall back to "R". */
8492 extended_remote_restart ();
8495 if (!have_inferiors ())
8497 /* Clean up from the last time we ran, before we mark the target
8498 running again. This will mark breakpoints uninserted, and
8499 get_offsets may insert breakpoints. */
8500 init_thread_list ();
8501 init_wait_for_inferior ();
8504 /* vRun's success return is a stop reply. */
8505 stop_reply
= run_worked
? rs
->buf
: NULL
;
8506 add_current_inferior_and_thread (stop_reply
);
8508 /* Get updated offsets, if the stub uses qOffsets. */
8513 /* Given a location's target info BP_TGT and the packet buffer BUF, output
8514 the list of conditions (in agent expression bytecode format), if any, the
8515 target needs to evaluate. The output is placed into the packet buffer
8516 started from BUF and ended at BUF_END. */
8519 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
8520 struct bp_target_info
*bp_tgt
, char *buf
,
8523 struct agent_expr
*aexpr
= NULL
;
8526 char *buf_start
= buf
;
8528 if (VEC_empty (agent_expr_p
, bp_tgt
->conditions
))
8531 buf
+= strlen (buf
);
8532 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
8535 /* Send conditions to the target and free the vector. */
8537 VEC_iterate (agent_expr_p
, bp_tgt
->conditions
, ix
, aexpr
);
8540 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
8541 buf
+= strlen (buf
);
8542 for (i
= 0; i
< aexpr
->len
; ++i
)
8543 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
8550 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
8551 struct bp_target_info
*bp_tgt
, char *buf
)
8553 struct agent_expr
*aexpr
= NULL
;
8556 if (VEC_empty (agent_expr_p
, bp_tgt
->tcommands
))
8559 buf
+= strlen (buf
);
8561 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
8562 buf
+= strlen (buf
);
8564 /* Concatenate all the agent expressions that are commands into the
8567 VEC_iterate (agent_expr_p
, bp_tgt
->tcommands
, ix
, aexpr
);
8570 sprintf (buf
, "X%x,", aexpr
->len
);
8571 buf
+= strlen (buf
);
8572 for (i
= 0; i
< aexpr
->len
; ++i
)
8573 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
8578 /* Insert a breakpoint. On targets that have software breakpoint
8579 support, we ask the remote target to do the work; on targets
8580 which don't, we insert a traditional memory breakpoint. */
8583 remote_insert_breakpoint (struct target_ops
*ops
,
8584 struct gdbarch
*gdbarch
,
8585 struct bp_target_info
*bp_tgt
)
8587 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
8588 If it succeeds, then set the support to PACKET_ENABLE. If it
8589 fails, and the user has explicitly requested the Z support then
8590 report an error, otherwise, mark it disabled and go on. */
8592 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
8594 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
8595 struct remote_state
*rs
;
8598 struct condition_list
*cond
= NULL
;
8600 /* Make sure the remote is pointing at the right process, if
8602 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8603 set_general_process ();
8605 gdbarch_remote_breakpoint_from_pc (gdbarch
, &addr
, &bpsize
);
8607 rs
= get_remote_state ();
8609 endbuf
= rs
->buf
+ get_remote_packet_size ();
8614 addr
= (ULONGEST
) remote_address_masked (addr
);
8615 p
+= hexnumstr (p
, addr
);
8616 xsnprintf (p
, endbuf
- p
, ",%d", bpsize
);
8618 if (remote_supports_cond_breakpoints (ops
))
8619 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
8621 if (remote_can_run_breakpoint_commands (ops
))
8622 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
8625 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8627 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
8632 bp_tgt
->placed_address
= addr
;
8633 bp_tgt
->placed_size
= bpsize
;
8635 case PACKET_UNKNOWN
:
8640 /* If this breakpoint has target-side commands but this stub doesn't
8641 support Z0 packets, throw error. */
8642 if (!VEC_empty (agent_expr_p
, bp_tgt
->tcommands
))
8643 throw_error (NOT_SUPPORTED_ERROR
, _("\
8644 Target doesn't support breakpoints that have target side commands."));
8646 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
8650 remote_remove_breakpoint (struct target_ops
*ops
,
8651 struct gdbarch
*gdbarch
,
8652 struct bp_target_info
*bp_tgt
)
8654 CORE_ADDR addr
= bp_tgt
->placed_address
;
8655 struct remote_state
*rs
= get_remote_state ();
8657 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
8660 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8662 /* Make sure the remote is pointing at the right process, if
8664 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8665 set_general_process ();
8671 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
8672 p
+= hexnumstr (p
, addr
);
8673 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->placed_size
);
8676 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8678 return (rs
->buf
[0] == 'E');
8681 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
8685 watchpoint_to_Z_packet (int type
)
8690 return Z_PACKET_WRITE_WP
;
8693 return Z_PACKET_READ_WP
;
8696 return Z_PACKET_ACCESS_WP
;
8699 internal_error (__FILE__
, __LINE__
,
8700 _("hw_bp_to_z: bad watchpoint type %d"), type
);
8705 remote_insert_watchpoint (struct target_ops
*self
,
8706 CORE_ADDR addr
, int len
, int type
,
8707 struct expression
*cond
)
8709 struct remote_state
*rs
= get_remote_state ();
8710 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8712 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
8714 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
8717 /* Make sure the remote is pointing at the right process, if
8719 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8720 set_general_process ();
8722 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
8723 p
= strchr (rs
->buf
, '\0');
8724 addr
= remote_address_masked (addr
);
8725 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8726 xsnprintf (p
, endbuf
- p
, ",%x", len
);
8729 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8731 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
8735 case PACKET_UNKNOWN
:
8740 internal_error (__FILE__
, __LINE__
,
8741 _("remote_insert_watchpoint: reached end of function"));
8745 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
8746 CORE_ADDR start
, int length
)
8748 CORE_ADDR diff
= remote_address_masked (addr
- start
);
8750 return diff
< length
;
8755 remote_remove_watchpoint (struct target_ops
*self
,
8756 CORE_ADDR addr
, int len
, int type
,
8757 struct expression
*cond
)
8759 struct remote_state
*rs
= get_remote_state ();
8760 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8762 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
8764 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
8767 /* Make sure the remote is pointing at the right process, if
8769 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8770 set_general_process ();
8772 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
8773 p
= strchr (rs
->buf
, '\0');
8774 addr
= remote_address_masked (addr
);
8775 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8776 xsnprintf (p
, endbuf
- p
, ",%x", len
);
8778 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8780 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
8783 case PACKET_UNKNOWN
:
8788 internal_error (__FILE__
, __LINE__
,
8789 _("remote_remove_watchpoint: reached end of function"));
8793 int remote_hw_watchpoint_limit
= -1;
8794 int remote_hw_watchpoint_length_limit
= -1;
8795 int remote_hw_breakpoint_limit
= -1;
8798 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
8799 CORE_ADDR addr
, int len
)
8801 if (remote_hw_watchpoint_length_limit
== 0)
8803 else if (remote_hw_watchpoint_length_limit
< 0)
8805 else if (len
<= remote_hw_watchpoint_length_limit
)
8812 remote_check_watch_resources (struct target_ops
*self
,
8813 int type
, int cnt
, int ot
)
8815 if (type
== bp_hardware_breakpoint
)
8817 if (remote_hw_breakpoint_limit
== 0)
8819 else if (remote_hw_breakpoint_limit
< 0)
8821 else if (cnt
<= remote_hw_breakpoint_limit
)
8826 if (remote_hw_watchpoint_limit
== 0)
8828 else if (remote_hw_watchpoint_limit
< 0)
8832 else if (cnt
<= remote_hw_watchpoint_limit
)
8838 /* The to_stopped_by_sw_breakpoint method of target remote. */
8841 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
8843 struct remote_state
*rs
= get_remote_state ();
8845 return rs
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
8848 /* The to_supports_stopped_by_sw_breakpoint method of target
8852 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
8854 struct remote_state
*rs
= get_remote_state ();
8856 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
8859 /* The to_stopped_by_hw_breakpoint method of target remote. */
8862 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
8864 struct remote_state
*rs
= get_remote_state ();
8866 return rs
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
8869 /* The to_supports_stopped_by_hw_breakpoint method of target
8873 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
8875 struct remote_state
*rs
= get_remote_state ();
8877 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
8881 remote_stopped_by_watchpoint (struct target_ops
*ops
)
8883 struct remote_state
*rs
= get_remote_state ();
8885 return rs
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
8889 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
8891 struct remote_state
*rs
= get_remote_state ();
8894 if (remote_stopped_by_watchpoint (target
))
8896 *addr_p
= rs
->remote_watch_data_address
;
8905 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
8906 struct bp_target_info
*bp_tgt
)
8908 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
8909 struct remote_state
*rs
;
8914 /* The length field should be set to the size of a breakpoint
8915 instruction, even though we aren't inserting one ourselves. */
8917 gdbarch_remote_breakpoint_from_pc (gdbarch
, &addr
, &bpsize
);
8919 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
8922 /* Make sure the remote is pointing at the right process, if
8924 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8925 set_general_process ();
8927 rs
= get_remote_state ();
8929 endbuf
= rs
->buf
+ get_remote_packet_size ();
8935 addr
= remote_address_masked (addr
);
8936 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8937 xsnprintf (p
, endbuf
- p
, ",%x", bpsize
);
8939 if (remote_supports_cond_breakpoints (self
))
8940 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
8942 if (remote_can_run_breakpoint_commands (self
))
8943 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
8946 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8948 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
8951 if (rs
->buf
[1] == '.')
8953 message
= strchr (rs
->buf
+ 2, '.');
8955 error (_("Remote failure reply: %s"), message
+ 1);
8958 case PACKET_UNKNOWN
:
8961 bp_tgt
->placed_address
= addr
;
8962 bp_tgt
->placed_size
= bpsize
;
8965 internal_error (__FILE__
, __LINE__
,
8966 _("remote_insert_hw_breakpoint: reached end of function"));
8971 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
8972 struct bp_target_info
*bp_tgt
)
8975 struct remote_state
*rs
= get_remote_state ();
8977 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8979 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
8982 /* Make sure the remote is pointing at the right process, if
8984 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8985 set_general_process ();
8991 addr
= remote_address_masked (bp_tgt
->placed_address
);
8992 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8993 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->placed_size
);
8996 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8998 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
9001 case PACKET_UNKNOWN
:
9006 internal_error (__FILE__
, __LINE__
,
9007 _("remote_remove_hw_breakpoint: reached end of function"));
9010 /* Verify memory using the "qCRC:" request. */
9013 remote_verify_memory (struct target_ops
*ops
,
9014 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
9016 struct remote_state
*rs
= get_remote_state ();
9017 unsigned long host_crc
, target_crc
;
9020 /* It doesn't make sense to use qCRC if the remote target is
9021 connected but not running. */
9022 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
9024 enum packet_result result
;
9026 /* Make sure the remote is pointing at the right process. */
9027 set_general_process ();
9029 /* FIXME: assumes lma can fit into long. */
9030 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
9031 (long) lma
, (long) size
);
9034 /* Be clever; compute the host_crc before waiting for target
9036 host_crc
= xcrc32 (data
, size
, 0xffffffff);
9038 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9040 result
= packet_ok (rs
->buf
,
9041 &remote_protocol_packets
[PACKET_qCRC
]);
9042 if (result
== PACKET_ERROR
)
9044 else if (result
== PACKET_OK
)
9046 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
9047 target_crc
= target_crc
* 16 + fromhex (*tmp
);
9049 return (host_crc
== target_crc
);
9053 return simple_verify_memory (ops
, data
, lma
, size
);
9056 /* compare-sections command
9058 With no arguments, compares each loadable section in the exec bfd
9059 with the same memory range on the target, and reports mismatches.
9060 Useful for verifying the image on the target against the exec file. */
9063 compare_sections_command (char *args
, int from_tty
)
9066 struct cleanup
*old_chain
;
9068 const char *sectname
;
9077 error (_("command cannot be used without an exec file"));
9079 /* Make sure the remote is pointing at the right process. */
9080 set_general_process ();
9082 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
9088 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
9090 if (!(s
->flags
& SEC_LOAD
))
9091 continue; /* Skip non-loadable section. */
9093 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
9094 continue; /* Skip writeable sections */
9096 size
= bfd_get_section_size (s
);
9098 continue; /* Skip zero-length section. */
9100 sectname
= bfd_get_section_name (exec_bfd
, s
);
9101 if (args
&& strcmp (args
, sectname
) != 0)
9102 continue; /* Not the section selected by user. */
9104 matched
= 1; /* Do this section. */
9107 sectdata
= xmalloc (size
);
9108 old_chain
= make_cleanup (xfree
, sectdata
);
9109 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
9111 res
= target_verify_memory (sectdata
, lma
, size
);
9114 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
9115 paddress (target_gdbarch (), lma
),
9116 paddress (target_gdbarch (), lma
+ size
));
9118 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
9119 paddress (target_gdbarch (), lma
),
9120 paddress (target_gdbarch (), lma
+ size
));
9122 printf_filtered ("matched.\n");
9125 printf_filtered ("MIS-MATCHED!\n");
9129 do_cleanups (old_chain
);
9132 warning (_("One or more sections of the target image does not match\n\
9133 the loaded file\n"));
9134 if (args
&& !matched
)
9135 printf_filtered (_("No loaded section named '%s'.\n"), args
);
9138 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
9139 into remote target. The number of bytes written to the remote
9140 target is returned, or -1 for error. */
9142 static enum target_xfer_status
9143 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
9144 const char *annex
, const gdb_byte
*writebuf
,
9145 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
9146 struct packet_config
*packet
)
9150 struct remote_state
*rs
= get_remote_state ();
9151 int max_size
= get_memory_write_packet_size ();
9153 if (packet
->support
== PACKET_DISABLE
)
9154 return TARGET_XFER_E_IO
;
9156 /* Insert header. */
9157 i
= snprintf (rs
->buf
, max_size
,
9158 "qXfer:%s:write:%s:%s:",
9159 object_name
, annex
? annex
: "",
9160 phex_nz (offset
, sizeof offset
));
9161 max_size
-= (i
+ 1);
9163 /* Escape as much data as fits into rs->buf. */
9164 buf_len
= remote_escape_output
9165 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
9167 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
9168 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
9169 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
9170 return TARGET_XFER_E_IO
;
9172 unpack_varlen_hex (rs
->buf
, &n
);
9175 return TARGET_XFER_OK
;
9178 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
9179 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
9180 number of bytes read is returned, or 0 for EOF, or -1 for error.
9181 The number of bytes read may be less than LEN without indicating an
9182 EOF. PACKET is checked and updated to indicate whether the remote
9183 target supports this object. */
9185 static enum target_xfer_status
9186 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
9188 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
9189 ULONGEST
*xfered_len
,
9190 struct packet_config
*packet
)
9192 struct remote_state
*rs
= get_remote_state ();
9193 LONGEST i
, n
, packet_len
;
9195 if (packet
->support
== PACKET_DISABLE
)
9196 return TARGET_XFER_E_IO
;
9198 /* Check whether we've cached an end-of-object packet that matches
9200 if (rs
->finished_object
)
9202 if (strcmp (object_name
, rs
->finished_object
) == 0
9203 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
9204 && offset
== rs
->finished_offset
)
9205 return TARGET_XFER_EOF
;
9208 /* Otherwise, we're now reading something different. Discard
9210 xfree (rs
->finished_object
);
9211 xfree (rs
->finished_annex
);
9212 rs
->finished_object
= NULL
;
9213 rs
->finished_annex
= NULL
;
9216 /* Request only enough to fit in a single packet. The actual data
9217 may not, since we don't know how much of it will need to be escaped;
9218 the target is free to respond with slightly less data. We subtract
9219 five to account for the response type and the protocol frame. */
9220 n
= min (get_remote_packet_size () - 5, len
);
9221 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
9222 object_name
, annex
? annex
: "",
9223 phex_nz (offset
, sizeof offset
),
9224 phex_nz (n
, sizeof n
));
9225 i
= putpkt (rs
->buf
);
9227 return TARGET_XFER_E_IO
;
9230 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
9231 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
9232 return TARGET_XFER_E_IO
;
9234 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
9235 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
9237 /* 'm' means there is (or at least might be) more data after this
9238 batch. That does not make sense unless there's at least one byte
9239 of data in this reply. */
9240 if (rs
->buf
[0] == 'm' && packet_len
== 1)
9241 error (_("Remote qXfer reply contained no data."));
9243 /* Got some data. */
9244 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
9245 packet_len
- 1, readbuf
, n
);
9247 /* 'l' is an EOF marker, possibly including a final block of data,
9248 or possibly empty. If we have the final block of a non-empty
9249 object, record this fact to bypass a subsequent partial read. */
9250 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
9252 rs
->finished_object
= xstrdup (object_name
);
9253 rs
->finished_annex
= xstrdup (annex
? annex
: "");
9254 rs
->finished_offset
= offset
+ i
;
9258 return TARGET_XFER_EOF
;
9262 return TARGET_XFER_OK
;
9266 static enum target_xfer_status
9267 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
9268 const char *annex
, gdb_byte
*readbuf
,
9269 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
9270 ULONGEST
*xfered_len
)
9272 struct remote_state
*rs
;
9276 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
9278 set_remote_traceframe ();
9279 set_general_thread (inferior_ptid
);
9281 rs
= get_remote_state ();
9283 /* Handle memory using the standard memory routines. */
9284 if (object
== TARGET_OBJECT_MEMORY
)
9286 /* If the remote target is connected but not running, we should
9287 pass this request down to a lower stratum (e.g. the executable
9289 if (!target_has_execution
)
9290 return TARGET_XFER_EOF
;
9292 if (writebuf
!= NULL
)
9293 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
9296 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
9300 /* Handle SPU memory using qxfer packets. */
9301 if (object
== TARGET_OBJECT_SPU
)
9304 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
9305 xfered_len
, &remote_protocol_packets
9306 [PACKET_qXfer_spu_read
]);
9308 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
9309 xfered_len
, &remote_protocol_packets
9310 [PACKET_qXfer_spu_write
]);
9313 /* Handle extra signal info using qxfer packets. */
9314 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
9317 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
9318 xfered_len
, &remote_protocol_packets
9319 [PACKET_qXfer_siginfo_read
]);
9321 return remote_write_qxfer (ops
, "siginfo", annex
,
9322 writebuf
, offset
, len
, xfered_len
,
9323 &remote_protocol_packets
9324 [PACKET_qXfer_siginfo_write
]);
9327 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
9330 return remote_read_qxfer (ops
, "statictrace", annex
,
9331 readbuf
, offset
, len
, xfered_len
,
9332 &remote_protocol_packets
9333 [PACKET_qXfer_statictrace_read
]);
9335 return TARGET_XFER_E_IO
;
9338 /* Only handle flash writes. */
9339 if (writebuf
!= NULL
)
9345 case TARGET_OBJECT_FLASH
:
9346 return remote_flash_write (ops
, offset
, len
, xfered_len
,
9350 return TARGET_XFER_E_IO
;
9354 /* Map pre-existing objects onto letters. DO NOT do this for new
9355 objects!!! Instead specify new query packets. */
9358 case TARGET_OBJECT_AVR
:
9362 case TARGET_OBJECT_AUXV
:
9363 gdb_assert (annex
== NULL
);
9364 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
9366 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
9368 case TARGET_OBJECT_AVAILABLE_FEATURES
:
9369 return remote_read_qxfer
9370 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
9371 &remote_protocol_packets
[PACKET_qXfer_features
]);
9373 case TARGET_OBJECT_LIBRARIES
:
9374 return remote_read_qxfer
9375 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
9376 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
9378 case TARGET_OBJECT_LIBRARIES_SVR4
:
9379 return remote_read_qxfer
9380 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
9381 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
9383 case TARGET_OBJECT_MEMORY_MAP
:
9384 gdb_assert (annex
== NULL
);
9385 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
9387 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
9389 case TARGET_OBJECT_OSDATA
:
9390 /* Should only get here if we're connected. */
9391 gdb_assert (rs
->remote_desc
);
9392 return remote_read_qxfer
9393 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
9394 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
9396 case TARGET_OBJECT_THREADS
:
9397 gdb_assert (annex
== NULL
);
9398 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
9400 &remote_protocol_packets
[PACKET_qXfer_threads
]);
9402 case TARGET_OBJECT_TRACEFRAME_INFO
:
9403 gdb_assert (annex
== NULL
);
9404 return remote_read_qxfer
9405 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
9406 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
9408 case TARGET_OBJECT_FDPIC
:
9409 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
9411 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
9413 case TARGET_OBJECT_OPENVMS_UIB
:
9414 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
9416 &remote_protocol_packets
[PACKET_qXfer_uib
]);
9418 case TARGET_OBJECT_BTRACE
:
9419 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
9421 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
9423 case TARGET_OBJECT_BTRACE_CONF
:
9424 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
9426 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
9428 case TARGET_OBJECT_EXEC_FILE
:
9429 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
9431 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
9434 return TARGET_XFER_E_IO
;
9437 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
9438 large enough let the caller deal with it. */
9439 if (len
< get_remote_packet_size ())
9440 return TARGET_XFER_E_IO
;
9441 len
= get_remote_packet_size ();
9443 /* Except for querying the minimum buffer size, target must be open. */
9444 if (!rs
->remote_desc
)
9445 error (_("remote query is only available after target open"));
9447 gdb_assert (annex
!= NULL
);
9448 gdb_assert (readbuf
!= NULL
);
9454 /* We used one buffer char for the remote protocol q command and
9455 another for the query type. As the remote protocol encapsulation
9456 uses 4 chars plus one extra in case we are debugging
9457 (remote_debug), we have PBUFZIZ - 7 left to pack the query
9460 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
9462 /* Bad caller may have sent forbidden characters. */
9463 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
9468 gdb_assert (annex
[i
] == '\0');
9470 i
= putpkt (rs
->buf
);
9472 return TARGET_XFER_E_IO
;
9474 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9475 strcpy ((char *) readbuf
, rs
->buf
);
9477 *xfered_len
= strlen ((char *) readbuf
);
9478 return TARGET_XFER_OK
;
9482 remote_search_memory (struct target_ops
* ops
,
9483 CORE_ADDR start_addr
, ULONGEST search_space_len
,
9484 const gdb_byte
*pattern
, ULONGEST pattern_len
,
9485 CORE_ADDR
*found_addrp
)
9487 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9488 struct remote_state
*rs
= get_remote_state ();
9489 int max_size
= get_memory_write_packet_size ();
9490 struct packet_config
*packet
=
9491 &remote_protocol_packets
[PACKET_qSearch_memory
];
9492 /* Number of packet bytes used to encode the pattern;
9493 this could be more than PATTERN_LEN due to escape characters. */
9494 int escaped_pattern_len
;
9495 /* Amount of pattern that was encodable in the packet. */
9496 int used_pattern_len
;
9499 ULONGEST found_addr
;
9501 /* Don't go to the target if we don't have to.
9502 This is done before checking packet->support to avoid the possibility that
9503 a success for this edge case means the facility works in general. */
9504 if (pattern_len
> search_space_len
)
9506 if (pattern_len
== 0)
9508 *found_addrp
= start_addr
;
9512 /* If we already know the packet isn't supported, fall back to the simple
9513 way of searching memory. */
9515 if (packet_config_support (packet
) == PACKET_DISABLE
)
9517 /* Target doesn't provided special support, fall back and use the
9518 standard support (copy memory and do the search here). */
9519 return simple_search_memory (ops
, start_addr
, search_space_len
,
9520 pattern
, pattern_len
, found_addrp
);
9523 /* Make sure the remote is pointing at the right process. */
9524 set_general_process ();
9526 /* Insert header. */
9527 i
= snprintf (rs
->buf
, max_size
,
9528 "qSearch:memory:%s;%s;",
9529 phex_nz (start_addr
, addr_size
),
9530 phex_nz (search_space_len
, sizeof (search_space_len
)));
9531 max_size
-= (i
+ 1);
9533 /* Escape as much data as fits into rs->buf. */
9534 escaped_pattern_len
=
9535 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
9536 &used_pattern_len
, max_size
);
9538 /* Bail if the pattern is too large. */
9539 if (used_pattern_len
!= pattern_len
)
9540 error (_("Pattern is too large to transmit to remote target."));
9542 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
9543 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
9544 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
9546 /* The request may not have worked because the command is not
9547 supported. If so, fall back to the simple way. */
9548 if (packet
->support
== PACKET_DISABLE
)
9550 return simple_search_memory (ops
, start_addr
, search_space_len
,
9551 pattern
, pattern_len
, found_addrp
);
9556 if (rs
->buf
[0] == '0')
9558 else if (rs
->buf
[0] == '1')
9561 if (rs
->buf
[1] != ',')
9562 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
9563 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
9564 *found_addrp
= found_addr
;
9567 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
9573 remote_rcmd (struct target_ops
*self
, const char *command
,
9574 struct ui_file
*outbuf
)
9576 struct remote_state
*rs
= get_remote_state ();
9579 if (!rs
->remote_desc
)
9580 error (_("remote rcmd is only available after target open"));
9582 /* Send a NULL command across as an empty command. */
9583 if (command
== NULL
)
9586 /* The query prefix. */
9587 strcpy (rs
->buf
, "qRcmd,");
9588 p
= strchr (rs
->buf
, '\0');
9590 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
9591 > get_remote_packet_size ())
9592 error (_("\"monitor\" command ``%s'' is too long."), command
);
9594 /* Encode the actual command. */
9595 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
9597 if (putpkt (rs
->buf
) < 0)
9598 error (_("Communication problem with target."));
9600 /* get/display the response */
9605 /* XXX - see also remote_get_noisy_reply(). */
9606 QUIT
; /* Allow user to bail out with ^C. */
9608 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
9610 /* Timeout. Continue to (try to) read responses.
9611 This is better than stopping with an error, assuming the stub
9612 is still executing the (long) monitor command.
9613 If needed, the user can interrupt gdb using C-c, obtaining
9614 an effect similar to stop on timeout. */
9619 error (_("Target does not support this command."));
9620 if (buf
[0] == 'O' && buf
[1] != 'K')
9622 remote_console_output (buf
+ 1); /* 'O' message from stub. */
9625 if (strcmp (buf
, "OK") == 0)
9627 if (strlen (buf
) == 3 && buf
[0] == 'E'
9628 && isdigit (buf
[1]) && isdigit (buf
[2]))
9630 error (_("Protocol error with Rcmd"));
9632 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
9634 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
9636 fputc_unfiltered (c
, outbuf
);
9642 static VEC(mem_region_s
) *
9643 remote_memory_map (struct target_ops
*ops
)
9645 VEC(mem_region_s
) *result
= NULL
;
9646 char *text
= target_read_stralloc (¤t_target
,
9647 TARGET_OBJECT_MEMORY_MAP
, NULL
);
9651 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
9653 result
= parse_memory_map (text
);
9654 do_cleanups (back_to
);
9661 packet_command (char *args
, int from_tty
)
9663 struct remote_state
*rs
= get_remote_state ();
9665 if (!rs
->remote_desc
)
9666 error (_("command can only be used with remote target"));
9669 error (_("remote-packet command requires packet text as argument"));
9671 puts_filtered ("sending: ");
9672 print_packet (args
);
9673 puts_filtered ("\n");
9676 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9677 puts_filtered ("received: ");
9678 print_packet (rs
->buf
);
9679 puts_filtered ("\n");
9683 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
9685 static void display_thread_info (struct gdb_ext_thread_info
*info
);
9687 static void threadset_test_cmd (char *cmd
, int tty
);
9689 static void threadalive_test (char *cmd
, int tty
);
9691 static void threadlist_test_cmd (char *cmd
, int tty
);
9693 int get_and_display_threadinfo (threadref
*ref
);
9695 static void threadinfo_test_cmd (char *cmd
, int tty
);
9697 static int thread_display_step (threadref
*ref
, void *context
);
9699 static void threadlist_update_test_cmd (char *cmd
, int tty
);
9701 static void init_remote_threadtests (void);
9703 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
9706 threadset_test_cmd (char *cmd
, int tty
)
9708 int sample_thread
= SAMPLE_THREAD
;
9710 printf_filtered (_("Remote threadset test\n"));
9711 set_general_thread (sample_thread
);
9716 threadalive_test (char *cmd
, int tty
)
9718 int sample_thread
= SAMPLE_THREAD
;
9719 int pid
= ptid_get_pid (inferior_ptid
);
9720 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
9722 if (remote_thread_alive (ptid
))
9723 printf_filtered ("PASS: Thread alive test\n");
9725 printf_filtered ("FAIL: Thread alive test\n");
9728 void output_threadid (char *title
, threadref
*ref
);
9731 output_threadid (char *title
, threadref
*ref
)
9735 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
9737 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
9741 threadlist_test_cmd (char *cmd
, int tty
)
9744 threadref nextthread
;
9745 int done
, result_count
;
9746 threadref threadlist
[3];
9748 printf_filtered ("Remote Threadlist test\n");
9749 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
9750 &result_count
, &threadlist
[0]))
9751 printf_filtered ("FAIL: threadlist test\n");
9754 threadref
*scan
= threadlist
;
9755 threadref
*limit
= scan
+ result_count
;
9757 while (scan
< limit
)
9758 output_threadid (" thread ", scan
++);
9763 display_thread_info (struct gdb_ext_thread_info
*info
)
9765 output_threadid ("Threadid: ", &info
->threadid
);
9766 printf_filtered ("Name: %s\n ", info
->shortname
);
9767 printf_filtered ("State: %s\n", info
->display
);
9768 printf_filtered ("other: %s\n\n", info
->more_display
);
9772 get_and_display_threadinfo (threadref
*ref
)
9776 struct gdb_ext_thread_info threadinfo
;
9778 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
9779 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
9780 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
9781 display_thread_info (&threadinfo
);
9786 threadinfo_test_cmd (char *cmd
, int tty
)
9788 int athread
= SAMPLE_THREAD
;
9792 int_to_threadref (&thread
, athread
);
9793 printf_filtered ("Remote Threadinfo test\n");
9794 if (!get_and_display_threadinfo (&thread
))
9795 printf_filtered ("FAIL cannot get thread info\n");
9799 thread_display_step (threadref
*ref
, void *context
)
9801 /* output_threadid(" threadstep ",ref); *//* simple test */
9802 return get_and_display_threadinfo (ref
);
9806 threadlist_update_test_cmd (char *cmd
, int tty
)
9808 printf_filtered ("Remote Threadlist update test\n");
9809 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
9813 init_remote_threadtests (void)
9815 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
9816 _("Fetch and print the remote list of "
9817 "thread identifiers, one pkt only"));
9818 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
9819 _("Fetch and display info about one thread"));
9820 add_com ("tset", class_obscure
, threadset_test_cmd
,
9821 _("Test setting to a different thread"));
9822 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
9823 _("Iterate through updating all remote thread info"));
9824 add_com ("talive", class_obscure
, threadalive_test
,
9825 _(" Remote thread alive test "));
9830 /* Convert a thread ID to a string. Returns the string in a static
9834 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
9836 static char buf
[64];
9837 struct remote_state
*rs
= get_remote_state ();
9839 if (ptid_equal (ptid
, null_ptid
))
9840 return normal_pid_to_str (ptid
);
9841 else if (ptid_is_pid (ptid
))
9843 /* Printing an inferior target id. */
9845 /* When multi-process extensions are off, there's no way in the
9846 remote protocol to know the remote process id, if there's any
9847 at all. There's one exception --- when we're connected with
9848 target extended-remote, and we manually attached to a process
9849 with "attach PID". We don't record anywhere a flag that
9850 allows us to distinguish that case from the case of
9851 connecting with extended-remote and the stub already being
9852 attached to a process, and reporting yes to qAttached, hence
9853 no smart special casing here. */
9854 if (!remote_multi_process_p (rs
))
9856 xsnprintf (buf
, sizeof buf
, "Remote target");
9860 return normal_pid_to_str (ptid
);
9864 if (ptid_equal (magic_null_ptid
, ptid
))
9865 xsnprintf (buf
, sizeof buf
, "Thread <main>");
9866 else if (rs
->extended
&& remote_multi_process_p (rs
))
9867 if (ptid_get_lwp (ptid
) == 0)
9868 return normal_pid_to_str (ptid
);
9870 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
9871 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
9873 xsnprintf (buf
, sizeof buf
, "Thread %ld",
9874 ptid_get_lwp (ptid
));
9879 /* Get the address of the thread local variable in OBJFILE which is
9880 stored at OFFSET within the thread local storage for thread PTID. */
9883 remote_get_thread_local_address (struct target_ops
*ops
,
9884 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
9886 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
9888 struct remote_state
*rs
= get_remote_state ();
9890 char *endp
= rs
->buf
+ get_remote_packet_size ();
9891 enum packet_result result
;
9893 strcpy (p
, "qGetTLSAddr:");
9895 p
= write_ptid (p
, endp
, ptid
);
9897 p
+= hexnumstr (p
, offset
);
9899 p
+= hexnumstr (p
, lm
);
9903 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9904 result
= packet_ok (rs
->buf
,
9905 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
9906 if (result
== PACKET_OK
)
9910 unpack_varlen_hex (rs
->buf
, &result
);
9913 else if (result
== PACKET_UNKNOWN
)
9914 throw_error (TLS_GENERIC_ERROR
,
9915 _("Remote target doesn't support qGetTLSAddr packet"));
9917 throw_error (TLS_GENERIC_ERROR
,
9918 _("Remote target failed to process qGetTLSAddr request"));
9921 throw_error (TLS_GENERIC_ERROR
,
9922 _("TLS not supported or disabled on this target"));
9927 /* Provide thread local base, i.e. Thread Information Block address.
9928 Returns 1 if ptid is found and thread_local_base is non zero. */
9931 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
9933 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
9935 struct remote_state
*rs
= get_remote_state ();
9937 char *endp
= rs
->buf
+ get_remote_packet_size ();
9938 enum packet_result result
;
9940 strcpy (p
, "qGetTIBAddr:");
9942 p
= write_ptid (p
, endp
, ptid
);
9946 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9947 result
= packet_ok (rs
->buf
,
9948 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
9949 if (result
== PACKET_OK
)
9953 unpack_varlen_hex (rs
->buf
, &result
);
9955 *addr
= (CORE_ADDR
) result
;
9958 else if (result
== PACKET_UNKNOWN
)
9959 error (_("Remote target doesn't support qGetTIBAddr packet"));
9961 error (_("Remote target failed to process qGetTIBAddr request"));
9964 error (_("qGetTIBAddr not supported or disabled on this target"));
9969 /* Support for inferring a target description based on the current
9970 architecture and the size of a 'g' packet. While the 'g' packet
9971 can have any size (since optional registers can be left off the
9972 end), some sizes are easily recognizable given knowledge of the
9973 approximate architecture. */
9975 struct remote_g_packet_guess
9978 const struct target_desc
*tdesc
;
9980 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
9981 DEF_VEC_O(remote_g_packet_guess_s
);
9983 struct remote_g_packet_data
9985 VEC(remote_g_packet_guess_s
) *guesses
;
9988 static struct gdbarch_data
*remote_g_packet_data_handle
;
9991 remote_g_packet_data_init (struct obstack
*obstack
)
9993 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
9997 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
9998 const struct target_desc
*tdesc
)
10000 struct remote_g_packet_data
*data
10001 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
10002 struct remote_g_packet_guess new_guess
, *guess
;
10005 gdb_assert (tdesc
!= NULL
);
10008 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
10010 if (guess
->bytes
== bytes
)
10011 internal_error (__FILE__
, __LINE__
,
10012 _("Duplicate g packet description added for size %d"),
10015 new_guess
.bytes
= bytes
;
10016 new_guess
.tdesc
= tdesc
;
10017 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
10020 /* Return 1 if remote_read_description would do anything on this target
10021 and architecture, 0 otherwise. */
10024 remote_read_description_p (struct target_ops
*target
)
10026 struct remote_g_packet_data
*data
10027 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
);
10029 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
10035 static const struct target_desc
*
10036 remote_read_description (struct target_ops
*target
)
10038 struct remote_g_packet_data
*data
10039 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
);
10041 /* Do not try this during initial connection, when we do not know
10042 whether there is a running but stopped thread. */
10043 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
10044 return target
->beneath
->to_read_description (target
->beneath
);
10046 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
10048 struct remote_g_packet_guess
*guess
;
10050 int bytes
= send_g_packet ();
10053 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
10055 if (guess
->bytes
== bytes
)
10056 return guess
->tdesc
;
10058 /* We discard the g packet. A minor optimization would be to
10059 hold on to it, and fill the register cache once we have selected
10060 an architecture, but it's too tricky to do safely. */
10063 return target
->beneath
->to_read_description (target
->beneath
);
10066 /* Remote file transfer support. This is host-initiated I/O, not
10067 target-initiated; for target-initiated, see remote-fileio.c. */
10069 /* If *LEFT is at least the length of STRING, copy STRING to
10070 *BUFFER, update *BUFFER to point to the new end of the buffer, and
10071 decrease *LEFT. Otherwise raise an error. */
10074 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
10076 int len
= strlen (string
);
10079 error (_("Packet too long for target."));
10081 memcpy (*buffer
, string
, len
);
10085 /* NUL-terminate the buffer as a convenience, if there is
10091 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
10092 *BUFFER, update *BUFFER to point to the new end of the buffer, and
10093 decrease *LEFT. Otherwise raise an error. */
10096 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
10099 if (2 * len
> *left
)
10100 error (_("Packet too long for target."));
10102 bin2hex (bytes
, *buffer
, len
);
10103 *buffer
+= 2 * len
;
10106 /* NUL-terminate the buffer as a convenience, if there is
10112 /* If *LEFT is large enough, convert VALUE to hex and add it to
10113 *BUFFER, update *BUFFER to point to the new end of the buffer, and
10114 decrease *LEFT. Otherwise raise an error. */
10117 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
10119 int len
= hexnumlen (value
);
10122 error (_("Packet too long for target."));
10124 hexnumstr (*buffer
, value
);
10128 /* NUL-terminate the buffer as a convenience, if there is
10134 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
10135 value, *REMOTE_ERRNO to the remote error number or zero if none
10136 was included, and *ATTACHMENT to point to the start of the annex
10137 if any. The length of the packet isn't needed here; there may
10138 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
10140 Return 0 if the packet could be parsed, -1 if it could not. If
10141 -1 is returned, the other variables may not be initialized. */
10144 remote_hostio_parse_result (char *buffer
, int *retcode
,
10145 int *remote_errno
, char **attachment
)
10150 *attachment
= NULL
;
10152 if (buffer
[0] != 'F')
10156 *retcode
= strtol (&buffer
[1], &p
, 16);
10157 if (errno
!= 0 || p
== &buffer
[1])
10160 /* Check for ",errno". */
10164 *remote_errno
= strtol (p
+ 1, &p2
, 16);
10165 if (errno
!= 0 || p
+ 1 == p2
)
10170 /* Check for ";attachment". If there is no attachment, the
10171 packet should end here. */
10174 *attachment
= p
+ 1;
10177 else if (*p
== '\0')
10183 /* Send a prepared I/O packet to the target and read its response.
10184 The prepared packet is in the global RS->BUF before this function
10185 is called, and the answer is there when we return.
10187 COMMAND_BYTES is the length of the request to send, which may include
10188 binary data. WHICH_PACKET is the packet configuration to check
10189 before attempting a packet. If an error occurs, *REMOTE_ERRNO
10190 is set to the error number and -1 is returned. Otherwise the value
10191 returned by the function is returned.
10193 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
10194 attachment is expected; an error will be reported if there's a
10195 mismatch. If one is found, *ATTACHMENT will be set to point into
10196 the packet buffer and *ATTACHMENT_LEN will be set to the
10197 attachment's length. */
10200 remote_hostio_send_command (int command_bytes
, int which_packet
,
10201 int *remote_errno
, char **attachment
,
10202 int *attachment_len
)
10204 struct remote_state
*rs
= get_remote_state ();
10205 int ret
, bytes_read
;
10206 char *attachment_tmp
;
10208 if (!rs
->remote_desc
10209 || packet_support (which_packet
) == PACKET_DISABLE
)
10211 *remote_errno
= FILEIO_ENOSYS
;
10215 putpkt_binary (rs
->buf
, command_bytes
);
10216 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10218 /* If it timed out, something is wrong. Don't try to parse the
10220 if (bytes_read
< 0)
10222 *remote_errno
= FILEIO_EINVAL
;
10226 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
10229 *remote_errno
= FILEIO_EINVAL
;
10231 case PACKET_UNKNOWN
:
10232 *remote_errno
= FILEIO_ENOSYS
;
10238 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
10241 *remote_errno
= FILEIO_EINVAL
;
10245 /* Make sure we saw an attachment if and only if we expected one. */
10246 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
10247 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
10249 *remote_errno
= FILEIO_EINVAL
;
10253 /* If an attachment was found, it must point into the packet buffer;
10254 work out how many bytes there were. */
10255 if (attachment_tmp
!= NULL
)
10257 *attachment
= attachment_tmp
;
10258 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
10264 /* Set the filesystem remote_hostio functions that take FILENAME
10265 arguments will use. Return 0 on success, or -1 if an error
10266 occurs (and set *REMOTE_ERRNO). */
10269 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
10271 struct remote_state
*rs
= get_remote_state ();
10272 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
10274 int left
= get_remote_packet_size () - 1;
10278 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
10281 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
10284 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
10286 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
10287 remote_buffer_add_string (&p
, &left
, arg
);
10289 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
10290 remote_errno
, NULL
, NULL
);
10292 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
10296 rs
->fs_pid
= required_pid
;
10301 /* Implementation of to_fileio_open. */
10304 remote_hostio_open (struct target_ops
*self
,
10305 struct inferior
*inf
, const char *filename
,
10306 int flags
, int mode
, int *remote_errno
)
10308 struct remote_state
*rs
= get_remote_state ();
10310 int left
= get_remote_packet_size () - 1;
10312 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
10315 remote_buffer_add_string (&p
, &left
, "vFile:open:");
10317 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
10318 strlen (filename
));
10319 remote_buffer_add_string (&p
, &left
, ",");
10321 remote_buffer_add_int (&p
, &left
, flags
);
10322 remote_buffer_add_string (&p
, &left
, ",");
10324 remote_buffer_add_int (&p
, &left
, mode
);
10326 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
10327 remote_errno
, NULL
, NULL
);
10330 /* Implementation of to_fileio_pwrite. */
10333 remote_hostio_pwrite (struct target_ops
*self
,
10334 int fd
, const gdb_byte
*write_buf
, int len
,
10335 ULONGEST offset
, int *remote_errno
)
10337 struct remote_state
*rs
= get_remote_state ();
10339 int left
= get_remote_packet_size ();
10342 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
10344 remote_buffer_add_int (&p
, &left
, fd
);
10345 remote_buffer_add_string (&p
, &left
, ",");
10347 remote_buffer_add_int (&p
, &left
, offset
);
10348 remote_buffer_add_string (&p
, &left
, ",");
10350 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
10351 get_remote_packet_size () - (p
- rs
->buf
));
10353 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
10354 remote_errno
, NULL
, NULL
);
10357 /* Implementation of to_fileio_pread. */
10360 remote_hostio_pread (struct target_ops
*self
,
10361 int fd
, gdb_byte
*read_buf
, int len
,
10362 ULONGEST offset
, int *remote_errno
)
10364 struct remote_state
*rs
= get_remote_state ();
10367 int left
= get_remote_packet_size ();
10368 int ret
, attachment_len
;
10371 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
10373 remote_buffer_add_int (&p
, &left
, fd
);
10374 remote_buffer_add_string (&p
, &left
, ",");
10376 remote_buffer_add_int (&p
, &left
, len
);
10377 remote_buffer_add_string (&p
, &left
, ",");
10379 remote_buffer_add_int (&p
, &left
, offset
);
10381 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
10382 remote_errno
, &attachment
,
10388 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
10390 if (read_len
!= ret
)
10391 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
10396 /* Implementation of to_fileio_close. */
10399 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
10401 struct remote_state
*rs
= get_remote_state ();
10403 int left
= get_remote_packet_size () - 1;
10405 remote_buffer_add_string (&p
, &left
, "vFile:close:");
10407 remote_buffer_add_int (&p
, &left
, fd
);
10409 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
10410 remote_errno
, NULL
, NULL
);
10413 /* Implementation of to_fileio_unlink. */
10416 remote_hostio_unlink (struct target_ops
*self
,
10417 struct inferior
*inf
, const char *filename
,
10420 struct remote_state
*rs
= get_remote_state ();
10422 int left
= get_remote_packet_size () - 1;
10424 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
10427 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
10429 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
10430 strlen (filename
));
10432 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
10433 remote_errno
, NULL
, NULL
);
10436 /* Implementation of to_fileio_readlink. */
10439 remote_hostio_readlink (struct target_ops
*self
,
10440 struct inferior
*inf
, const char *filename
,
10443 struct remote_state
*rs
= get_remote_state ();
10446 int left
= get_remote_packet_size ();
10447 int len
, attachment_len
;
10451 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
10454 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
10456 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
10457 strlen (filename
));
10459 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
10460 remote_errno
, &attachment
,
10466 ret
= xmalloc (len
+ 1);
10468 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
10469 (gdb_byte
*) ret
, len
);
10470 if (read_len
!= len
)
10471 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
10477 /* Implementation of to_fileio_fstat. */
10480 remote_hostio_fstat (struct target_ops
*self
,
10481 int fd
, struct stat
*st
,
10484 struct remote_state
*rs
= get_remote_state ();
10486 int left
= get_remote_packet_size ();
10487 int attachment_len
, ret
;
10489 struct fio_stat fst
;
10492 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
10494 remote_buffer_add_int (&p
, &left
, fd
);
10496 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
10497 remote_errno
, &attachment
,
10501 if (*remote_errno
!= FILEIO_ENOSYS
)
10504 /* Strictly we should return -1, ENOSYS here, but when
10505 "set sysroot remote:" was implemented in August 2008
10506 BFD's need for a stat function was sidestepped with
10507 this hack. This was not remedied until March 2015
10508 so we retain the previous behavior to avoid breaking
10511 Note that the memset is a March 2015 addition; older
10512 GDBs set st_size *and nothing else* so the structure
10513 would have garbage in all other fields. This might
10514 break something but retaining the previous behavior
10515 here would be just too wrong. */
10517 memset (st
, 0, sizeof (struct stat
));
10518 st
->st_size
= INT_MAX
;
10522 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
10523 (gdb_byte
*) &fst
, sizeof (fst
));
10525 if (read_len
!= ret
)
10526 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
10528 if (read_len
!= sizeof (fst
))
10529 error (_("vFile:fstat returned %d bytes, but expecting %d."),
10530 read_len
, (int) sizeof (fst
));
10532 remote_fileio_to_host_stat (&fst
, st
);
10537 /* Implementation of to_filesystem_is_local. */
10540 remote_filesystem_is_local (struct target_ops
*self
)
10542 /* Valgrind GDB presents itself as a remote target but works
10543 on the local filesystem: it does not implement remote get
10544 and users are not expected to set a sysroot. To handle
10545 this case we treat the remote filesystem as local if the
10546 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
10547 does not support vFile:open. */
10548 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
10550 enum packet_support ps
= packet_support (PACKET_vFile_open
);
10552 if (ps
== PACKET_SUPPORT_UNKNOWN
)
10554 int fd
, remote_errno
;
10556 /* Try opening a file to probe support. The supplied
10557 filename is irrelevant, we only care about whether
10558 the stub recognizes the packet or not. */
10559 fd
= remote_hostio_open (self
, NULL
, "just probing",
10560 FILEIO_O_RDONLY
, 0700,
10564 remote_hostio_close (self
, fd
, &remote_errno
);
10566 ps
= packet_support (PACKET_vFile_open
);
10569 if (ps
== PACKET_DISABLE
)
10571 static int warning_issued
= 0;
10573 if (!warning_issued
)
10575 warning (_("remote target does not support file"
10576 " transfer, attempting to access files"
10577 " from local filesystem."));
10578 warning_issued
= 1;
10589 remote_fileio_errno_to_host (int errnum
)
10595 case FILEIO_ENOENT
:
10603 case FILEIO_EACCES
:
10605 case FILEIO_EFAULT
:
10609 case FILEIO_EEXIST
:
10611 case FILEIO_ENODEV
:
10613 case FILEIO_ENOTDIR
:
10615 case FILEIO_EISDIR
:
10617 case FILEIO_EINVAL
:
10619 case FILEIO_ENFILE
:
10621 case FILEIO_EMFILE
:
10625 case FILEIO_ENOSPC
:
10627 case FILEIO_ESPIPE
:
10631 case FILEIO_ENOSYS
:
10633 case FILEIO_ENAMETOOLONG
:
10634 return ENAMETOOLONG
;
10640 remote_hostio_error (int errnum
)
10642 int host_error
= remote_fileio_errno_to_host (errnum
);
10644 if (host_error
== -1)
10645 error (_("Unknown remote I/O error %d"), errnum
);
10647 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
10651 remote_hostio_close_cleanup (void *opaque
)
10653 int fd
= *(int *) opaque
;
10656 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
10660 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
10662 struct cleanup
*back_to
, *close_cleanup
;
10663 int retcode
, fd
, remote_errno
, bytes
, io_size
;
10666 int bytes_in_buffer
;
10669 struct remote_state
*rs
= get_remote_state ();
10671 if (!rs
->remote_desc
)
10672 error (_("command can only be used with remote target"));
10674 file
= gdb_fopen_cloexec (local_file
, "rb");
10676 perror_with_name (local_file
);
10677 back_to
= make_cleanup_fclose (file
);
10679 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
10680 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
10682 0700, &remote_errno
);
10684 remote_hostio_error (remote_errno
);
10686 /* Send up to this many bytes at once. They won't all fit in the
10687 remote packet limit, so we'll transfer slightly fewer. */
10688 io_size
= get_remote_packet_size ();
10689 buffer
= xmalloc (io_size
);
10690 make_cleanup (xfree
, buffer
);
10692 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
10694 bytes_in_buffer
= 0;
10697 while (bytes_in_buffer
|| !saw_eof
)
10701 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
10702 io_size
- bytes_in_buffer
,
10707 error (_("Error reading %s."), local_file
);
10710 /* EOF. Unless there is something still in the
10711 buffer from the last iteration, we are done. */
10713 if (bytes_in_buffer
== 0)
10721 bytes
+= bytes_in_buffer
;
10722 bytes_in_buffer
= 0;
10724 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
10726 offset
, &remote_errno
);
10729 remote_hostio_error (remote_errno
);
10730 else if (retcode
== 0)
10731 error (_("Remote write of %d bytes returned 0!"), bytes
);
10732 else if (retcode
< bytes
)
10734 /* Short write. Save the rest of the read data for the next
10736 bytes_in_buffer
= bytes
- retcode
;
10737 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
10743 discard_cleanups (close_cleanup
);
10744 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
10745 remote_hostio_error (remote_errno
);
10748 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
10749 do_cleanups (back_to
);
10753 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
10755 struct cleanup
*back_to
, *close_cleanup
;
10756 int fd
, remote_errno
, bytes
, io_size
;
10760 struct remote_state
*rs
= get_remote_state ();
10762 if (!rs
->remote_desc
)
10763 error (_("command can only be used with remote target"));
10765 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
10766 remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
10768 remote_hostio_error (remote_errno
);
10770 file
= gdb_fopen_cloexec (local_file
, "wb");
10772 perror_with_name (local_file
);
10773 back_to
= make_cleanup_fclose (file
);
10775 /* Send up to this many bytes at once. They won't all fit in the
10776 remote packet limit, so we'll transfer slightly fewer. */
10777 io_size
= get_remote_packet_size ();
10778 buffer
= xmalloc (io_size
);
10779 make_cleanup (xfree
, buffer
);
10781 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
10786 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
10787 fd
, buffer
, io_size
, offset
, &remote_errno
);
10789 /* Success, but no bytes, means end-of-file. */
10792 remote_hostio_error (remote_errno
);
10796 bytes
= fwrite (buffer
, 1, bytes
, file
);
10798 perror_with_name (local_file
);
10801 discard_cleanups (close_cleanup
);
10802 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
10803 remote_hostio_error (remote_errno
);
10806 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
10807 do_cleanups (back_to
);
10811 remote_file_delete (const char *remote_file
, int from_tty
)
10813 int retcode
, remote_errno
;
10814 struct remote_state
*rs
= get_remote_state ();
10816 if (!rs
->remote_desc
)
10817 error (_("command can only be used with remote target"));
10819 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
10820 NULL
, remote_file
, &remote_errno
);
10822 remote_hostio_error (remote_errno
);
10825 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
10829 remote_put_command (char *args
, int from_tty
)
10831 struct cleanup
*back_to
;
10835 error_no_arg (_("file to put"));
10837 argv
= gdb_buildargv (args
);
10838 back_to
= make_cleanup_freeargv (argv
);
10839 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
10840 error (_("Invalid parameters to remote put"));
10842 remote_file_put (argv
[0], argv
[1], from_tty
);
10844 do_cleanups (back_to
);
10848 remote_get_command (char *args
, int from_tty
)
10850 struct cleanup
*back_to
;
10854 error_no_arg (_("file to get"));
10856 argv
= gdb_buildargv (args
);
10857 back_to
= make_cleanup_freeargv (argv
);
10858 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
10859 error (_("Invalid parameters to remote get"));
10861 remote_file_get (argv
[0], argv
[1], from_tty
);
10863 do_cleanups (back_to
);
10867 remote_delete_command (char *args
, int from_tty
)
10869 struct cleanup
*back_to
;
10873 error_no_arg (_("file to delete"));
10875 argv
= gdb_buildargv (args
);
10876 back_to
= make_cleanup_freeargv (argv
);
10877 if (argv
[0] == NULL
|| argv
[1] != NULL
)
10878 error (_("Invalid parameters to remote delete"));
10880 remote_file_delete (argv
[0], from_tty
);
10882 do_cleanups (back_to
);
10886 remote_command (char *args
, int from_tty
)
10888 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
10892 remote_can_execute_reverse (struct target_ops
*self
)
10894 if (packet_support (PACKET_bs
) == PACKET_ENABLE
10895 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
10902 remote_supports_non_stop (struct target_ops
*self
)
10908 remote_supports_disable_randomization (struct target_ops
*self
)
10910 /* Only supported in extended mode. */
10915 remote_supports_multi_process (struct target_ops
*self
)
10917 struct remote_state
*rs
= get_remote_state ();
10919 /* Only extended-remote handles being attached to multiple
10920 processes, even though plain remote can use the multi-process
10921 thread id extensions, so that GDB knows the target process's
10923 return rs
->extended
&& remote_multi_process_p (rs
);
10927 remote_supports_cond_tracepoints (void)
10929 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
10933 remote_supports_cond_breakpoints (struct target_ops
*self
)
10935 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
10939 remote_supports_fast_tracepoints (void)
10941 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
10945 remote_supports_static_tracepoints (void)
10947 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
10951 remote_supports_install_in_trace (void)
10953 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
10957 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
10959 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
10964 remote_supports_string_tracing (struct target_ops
*self
)
10966 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
10970 remote_can_run_breakpoint_commands (struct target_ops
*self
)
10972 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
10976 remote_trace_init (struct target_ops
*self
)
10979 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10980 if (strcmp (target_buf
, "OK") != 0)
10981 error (_("Target does not support this command."));
10984 static void free_actions_list (char **actions_list
);
10985 static void free_actions_list_cleanup_wrapper (void *);
10987 free_actions_list_cleanup_wrapper (void *al
)
10989 free_actions_list (al
);
10993 free_actions_list (char **actions_list
)
10997 if (actions_list
== 0)
11000 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
11001 xfree (actions_list
[ndx
]);
11003 xfree (actions_list
);
11006 /* Recursive routine to walk through command list including loops, and
11007 download packets for each command. */
11010 remote_download_command_source (int num
, ULONGEST addr
,
11011 struct command_line
*cmds
)
11013 struct remote_state
*rs
= get_remote_state ();
11014 struct command_line
*cmd
;
11016 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
11018 QUIT
; /* Allow user to bail out with ^C. */
11019 strcpy (rs
->buf
, "QTDPsrc:");
11020 encode_source_string (num
, addr
, "cmd", cmd
->line
,
11021 rs
->buf
+ strlen (rs
->buf
),
11022 rs
->buf_size
- strlen (rs
->buf
));
11024 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11025 if (strcmp (target_buf
, "OK"))
11026 warning (_("Target does not support source download."));
11028 if (cmd
->control_type
== while_control
11029 || cmd
->control_type
== while_stepping_control
)
11031 remote_download_command_source (num
, addr
, *cmd
->body_list
);
11033 QUIT
; /* Allow user to bail out with ^C. */
11034 strcpy (rs
->buf
, "QTDPsrc:");
11035 encode_source_string (num
, addr
, "cmd", "end",
11036 rs
->buf
+ strlen (rs
->buf
),
11037 rs
->buf_size
- strlen (rs
->buf
));
11039 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11040 if (strcmp (target_buf
, "OK"))
11041 warning (_("Target does not support source download."));
11047 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
11049 #define BUF_SIZE 2048
11053 char buf
[BUF_SIZE
];
11054 char **tdp_actions
;
11055 char **stepping_actions
;
11057 struct cleanup
*old_chain
= NULL
;
11058 struct agent_expr
*aexpr
;
11059 struct cleanup
*aexpr_chain
= NULL
;
11061 struct breakpoint
*b
= loc
->owner
;
11062 struct tracepoint
*t
= (struct tracepoint
*) b
;
11064 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
11065 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
11067 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
11070 tpaddr
= loc
->address
;
11071 sprintf_vma (addrbuf
, tpaddr
);
11072 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
11073 addrbuf
, /* address */
11074 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
11075 t
->step_count
, t
->pass_count
);
11076 /* Fast tracepoints are mostly handled by the target, but we can
11077 tell the target how big of an instruction block should be moved
11079 if (b
->type
== bp_fast_tracepoint
)
11081 /* Only test for support at download time; we may not know
11082 target capabilities at definition time. */
11083 if (remote_supports_fast_tracepoints ())
11087 if (gdbarch_fast_tracepoint_valid_at (target_gdbarch (),
11088 tpaddr
, &isize
, NULL
))
11089 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
11092 /* If it passed validation at definition but fails now,
11093 something is very wrong. */
11094 internal_error (__FILE__
, __LINE__
,
11095 _("Fast tracepoint not "
11096 "valid during download"));
11099 /* Fast tracepoints are functionally identical to regular
11100 tracepoints, so don't take lack of support as a reason to
11101 give up on the trace run. */
11102 warning (_("Target does not support fast tracepoints, "
11103 "downloading %d as regular tracepoint"), b
->number
);
11105 else if (b
->type
== bp_static_tracepoint
)
11107 /* Only test for support at download time; we may not know
11108 target capabilities at definition time. */
11109 if (remote_supports_static_tracepoints ())
11111 struct static_tracepoint_marker marker
;
11113 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
11114 strcat (buf
, ":S");
11116 error (_("Static tracepoint not valid during download"));
11119 /* Fast tracepoints are functionally identical to regular
11120 tracepoints, so don't take lack of support as a reason
11121 to give up on the trace run. */
11122 error (_("Target does not support static tracepoints"));
11124 /* If the tracepoint has a conditional, make it into an agent
11125 expression and append to the definition. */
11128 /* Only test support at download time, we may not know target
11129 capabilities at definition time. */
11130 if (remote_supports_cond_tracepoints ())
11132 aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
);
11133 aexpr_chain
= make_cleanup_free_agent_expr (aexpr
);
11134 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
11136 pkt
= buf
+ strlen (buf
);
11137 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
11138 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
11140 do_cleanups (aexpr_chain
);
11143 warning (_("Target does not support conditional tracepoints, "
11144 "ignoring tp %d cond"), b
->number
);
11147 if (b
->commands
|| *default_collect
)
11150 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11151 if (strcmp (target_buf
, "OK"))
11152 error (_("Target does not support tracepoints."));
11154 /* do_single_steps (t); */
11157 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
11159 QUIT
; /* Allow user to bail out with ^C. */
11160 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
11161 b
->number
, addrbuf
, /* address */
11163 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
11166 remote_get_noisy_reply (&target_buf
,
11168 if (strcmp (target_buf
, "OK"))
11169 error (_("Error on target while setting tracepoints."));
11172 if (stepping_actions
)
11174 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
11176 QUIT
; /* Allow user to bail out with ^C. */
11177 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
11178 b
->number
, addrbuf
, /* address */
11179 ((ndx
== 0) ? "S" : ""),
11180 stepping_actions
[ndx
],
11181 (stepping_actions
[ndx
+ 1] ? "-" : ""));
11183 remote_get_noisy_reply (&target_buf
,
11185 if (strcmp (target_buf
, "OK"))
11186 error (_("Error on target while setting tracepoints."));
11190 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
11192 if (b
->addr_string
)
11194 strcpy (buf
, "QTDPsrc:");
11195 encode_source_string (b
->number
, loc
->address
,
11196 "at", b
->addr_string
, buf
+ strlen (buf
),
11197 2048 - strlen (buf
));
11200 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11201 if (strcmp (target_buf
, "OK"))
11202 warning (_("Target does not support source download."));
11204 if (b
->cond_string
)
11206 strcpy (buf
, "QTDPsrc:");
11207 encode_source_string (b
->number
, loc
->address
,
11208 "cond", b
->cond_string
, buf
+ strlen (buf
),
11209 2048 - strlen (buf
));
11211 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11212 if (strcmp (target_buf
, "OK"))
11213 warning (_("Target does not support source download."));
11215 remote_download_command_source (b
->number
, loc
->address
,
11216 breakpoint_commands (b
));
11219 do_cleanups (old_chain
);
11223 remote_can_download_tracepoint (struct target_ops
*self
)
11225 struct remote_state
*rs
= get_remote_state ();
11226 struct trace_status
*ts
;
11229 /* Don't try to install tracepoints until we've relocated our
11230 symbols, and fetched and merged the target's tracepoint list with
11232 if (rs
->starting_up
)
11235 ts
= current_trace_status ();
11236 status
= remote_get_trace_status (self
, ts
);
11238 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
11241 /* If we are in a tracing experiment, but remote stub doesn't support
11242 installing tracepoint in trace, we have to return. */
11243 if (!remote_supports_install_in_trace ())
11251 remote_download_trace_state_variable (struct target_ops
*self
,
11252 struct trace_state_variable
*tsv
)
11254 struct remote_state
*rs
= get_remote_state ();
11257 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
11258 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
11260 p
= rs
->buf
+ strlen (rs
->buf
);
11261 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
11262 error (_("Trace state variable name too long for tsv definition packet"));
11263 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
11266 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11267 if (*target_buf
== '\0')
11268 error (_("Target does not support this command."));
11269 if (strcmp (target_buf
, "OK") != 0)
11270 error (_("Error on target while downloading trace state variable."));
11274 remote_enable_tracepoint (struct target_ops
*self
,
11275 struct bp_location
*location
)
11277 struct remote_state
*rs
= get_remote_state ();
11280 sprintf_vma (addr_buf
, location
->address
);
11281 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
11282 location
->owner
->number
, addr_buf
);
11284 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
11285 if (*rs
->buf
== '\0')
11286 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
11287 if (strcmp (rs
->buf
, "OK") != 0)
11288 error (_("Error on target while enabling tracepoint."));
11292 remote_disable_tracepoint (struct target_ops
*self
,
11293 struct bp_location
*location
)
11295 struct remote_state
*rs
= get_remote_state ();
11298 sprintf_vma (addr_buf
, location
->address
);
11299 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
11300 location
->owner
->number
, addr_buf
);
11302 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
11303 if (*rs
->buf
== '\0')
11304 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
11305 if (strcmp (rs
->buf
, "OK") != 0)
11306 error (_("Error on target while disabling tracepoint."));
11310 remote_trace_set_readonly_regions (struct target_ops
*self
)
11314 bfd_size_type size
;
11320 return; /* No information to give. */
11322 strcpy (target_buf
, "QTro");
11323 offset
= strlen (target_buf
);
11324 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
11326 char tmp1
[40], tmp2
[40];
11329 if ((s
->flags
& SEC_LOAD
) == 0 ||
11330 /* (s->flags & SEC_CODE) == 0 || */
11331 (s
->flags
& SEC_READONLY
) == 0)
11335 vma
= bfd_get_section_vma (abfd
, s
);
11336 size
= bfd_get_section_size (s
);
11337 sprintf_vma (tmp1
, vma
);
11338 sprintf_vma (tmp2
, vma
+ size
);
11339 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
11340 if (offset
+ sec_length
+ 1 > target_buf_size
)
11342 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
11344 Too many sections for read-only sections definition packet."));
11347 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
11349 offset
+= sec_length
;
11353 putpkt (target_buf
);
11354 getpkt (&target_buf
, &target_buf_size
, 0);
11359 remote_trace_start (struct target_ops
*self
)
11361 putpkt ("QTStart");
11362 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11363 if (*target_buf
== '\0')
11364 error (_("Target does not support this command."));
11365 if (strcmp (target_buf
, "OK") != 0)
11366 error (_("Bogus reply from target: %s"), target_buf
);
11370 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
11372 /* Initialize it just to avoid a GCC false warning. */
11374 /* FIXME we need to get register block size some other way. */
11375 extern int trace_regblock_size
;
11376 enum packet_result result
;
11378 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
11381 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
11383 putpkt ("qTStatus");
11387 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11389 CATCH (ex
, RETURN_MASK_ERROR
)
11391 if (ex
.error
!= TARGET_CLOSE_ERROR
)
11393 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
11396 throw_exception (ex
);
11400 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
11402 /* If the remote target doesn't do tracing, flag it. */
11403 if (result
== PACKET_UNKNOWN
)
11406 /* We're working with a live target. */
11407 ts
->filename
= NULL
;
11410 error (_("Bogus trace status reply from target: %s"), target_buf
);
11412 /* Function 'parse_trace_status' sets default value of each field of
11413 'ts' at first, so we don't have to do it here. */
11414 parse_trace_status (p
, ts
);
11416 return ts
->running
;
11420 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
11421 struct uploaded_tp
*utp
)
11423 struct remote_state
*rs
= get_remote_state ();
11425 struct bp_location
*loc
;
11426 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
11427 size_t size
= get_remote_packet_size ();
11431 tp
->base
.hit_count
= 0;
11432 tp
->traceframe_usage
= 0;
11433 for (loc
= tp
->base
.loc
; loc
; loc
= loc
->next
)
11435 /* If the tracepoint was never downloaded, don't go asking for
11437 if (tp
->number_on_target
== 0)
11439 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
11440 phex_nz (loc
->address
, 0));
11442 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11443 if (reply
&& *reply
)
11446 parse_tracepoint_status (reply
+ 1, bp
, utp
);
11452 utp
->hit_count
= 0;
11453 utp
->traceframe_usage
= 0;
11454 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
11455 phex_nz (utp
->addr
, 0));
11457 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11458 if (reply
&& *reply
)
11461 parse_tracepoint_status (reply
+ 1, bp
, utp
);
11467 remote_trace_stop (struct target_ops
*self
)
11470 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11471 if (*target_buf
== '\0')
11472 error (_("Target does not support this command."));
11473 if (strcmp (target_buf
, "OK") != 0)
11474 error (_("Bogus reply from target: %s"), target_buf
);
11478 remote_trace_find (struct target_ops
*self
,
11479 enum trace_find_type type
, int num
,
11480 CORE_ADDR addr1
, CORE_ADDR addr2
,
11483 struct remote_state
*rs
= get_remote_state ();
11484 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11486 int target_frameno
= -1, target_tracept
= -1;
11488 /* Lookups other than by absolute frame number depend on the current
11489 trace selected, so make sure it is correct on the remote end
11491 if (type
!= tfind_number
)
11492 set_remote_traceframe ();
11495 strcpy (p
, "QTFrame:");
11496 p
= strchr (p
, '\0');
11500 xsnprintf (p
, endbuf
- p
, "%x", num
);
11503 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
11506 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
11509 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
11510 phex_nz (addr2
, 0));
11512 case tfind_outside
:
11513 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
11514 phex_nz (addr2
, 0));
11517 error (_("Unknown trace find type %d"), type
);
11521 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
11522 if (*reply
== '\0')
11523 error (_("Target does not support this command."));
11525 while (reply
&& *reply
)
11530 target_frameno
= (int) strtol (p
, &reply
, 16);
11532 error (_("Unable to parse trace frame number"));
11533 /* Don't update our remote traceframe number cache on failure
11534 to select a remote traceframe. */
11535 if (target_frameno
== -1)
11540 target_tracept
= (int) strtol (p
, &reply
, 16);
11542 error (_("Unable to parse tracepoint number"));
11544 case 'O': /* "OK"? */
11545 if (reply
[1] == 'K' && reply
[2] == '\0')
11548 error (_("Bogus reply from target: %s"), reply
);
11551 error (_("Bogus reply from target: %s"), reply
);
11554 *tpp
= target_tracept
;
11556 rs
->remote_traceframe_number
= target_frameno
;
11557 return target_frameno
;
11561 remote_get_trace_state_variable_value (struct target_ops
*self
,
11562 int tsvnum
, LONGEST
*val
)
11564 struct remote_state
*rs
= get_remote_state ();
11568 set_remote_traceframe ();
11570 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
11572 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11573 if (reply
&& *reply
)
11577 unpack_varlen_hex (reply
+ 1, &uval
);
11578 *val
= (LONGEST
) uval
;
11586 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
11588 struct remote_state
*rs
= get_remote_state ();
11592 strcpy (p
, "QTSave:");
11594 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
11595 error (_("Remote file name too long for trace save packet"));
11596 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
11599 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11600 if (*reply
== '\0')
11601 error (_("Target does not support this command."));
11602 if (strcmp (reply
, "OK") != 0)
11603 error (_("Bogus reply from target: %s"), reply
);
11607 /* This is basically a memory transfer, but needs to be its own packet
11608 because we don't know how the target actually organizes its trace
11609 memory, plus we want to be able to ask for as much as possible, but
11610 not be unhappy if we don't get as much as we ask for. */
11613 remote_get_raw_trace_data (struct target_ops
*self
,
11614 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
11616 struct remote_state
*rs
= get_remote_state ();
11622 strcpy (p
, "qTBuffer:");
11624 p
+= hexnumstr (p
, offset
);
11626 p
+= hexnumstr (p
, len
);
11630 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11631 if (reply
&& *reply
)
11633 /* 'l' by itself means we're at the end of the buffer and
11634 there is nothing more to get. */
11638 /* Convert the reply into binary. Limit the number of bytes to
11639 convert according to our passed-in buffer size, rather than
11640 what was returned in the packet; if the target is
11641 unexpectedly generous and gives us a bigger reply than we
11642 asked for, we don't want to crash. */
11643 rslt
= hex2bin (target_buf
, buf
, len
);
11647 /* Something went wrong, flag as an error. */
11652 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
11654 struct remote_state
*rs
= get_remote_state ();
11656 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
11660 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
11662 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11663 if (*reply
== '\0')
11664 error (_("Target does not support this command."));
11665 if (strcmp (reply
, "OK") != 0)
11666 error (_("Bogus reply from target: %s"), reply
);
11669 warning (_("Target does not support disconnected tracing."));
11673 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
11675 struct thread_info
*info
= find_thread_ptid (ptid
);
11677 if (info
&& info
->priv
)
11678 return info
->priv
->core
;
11683 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
11685 struct remote_state
*rs
= get_remote_state ();
11688 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
11690 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11691 if (*reply
== '\0')
11692 error (_("Target does not support this command."));
11693 if (strcmp (reply
, "OK") != 0)
11694 error (_("Bogus reply from target: %s"), reply
);
11697 static struct traceframe_info
*
11698 remote_traceframe_info (struct target_ops
*self
)
11702 text
= target_read_stralloc (¤t_target
,
11703 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
11706 struct traceframe_info
*info
;
11707 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
11709 info
= parse_traceframe_info (text
);
11710 do_cleanups (back_to
);
11717 /* Handle the qTMinFTPILen packet. Returns the minimum length of
11718 instruction on which a fast tracepoint may be placed. Returns -1
11719 if the packet is not supported, and 0 if the minimum instruction
11720 length is unknown. */
11723 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
11725 struct remote_state
*rs
= get_remote_state ();
11728 /* If we're not debugging a process yet, the IPA can't be
11730 if (!target_has_execution
)
11733 /* Make sure the remote is pointing at the right process. */
11734 set_general_process ();
11736 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
11738 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11739 if (*reply
== '\0')
11743 ULONGEST min_insn_len
;
11745 unpack_varlen_hex (reply
, &min_insn_len
);
11747 return (int) min_insn_len
;
11752 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
11754 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
11756 struct remote_state
*rs
= get_remote_state ();
11757 char *buf
= rs
->buf
;
11758 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11759 enum packet_result result
;
11761 gdb_assert (val
>= 0 || val
== -1);
11762 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
11763 /* Send -1 as literal "-1" to avoid host size dependency. */
11767 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
11770 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
11773 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
11774 result
= packet_ok (rs
->buf
,
11775 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
11777 if (result
!= PACKET_OK
)
11778 warning (_("Bogus reply from target: %s"), rs
->buf
);
11783 remote_set_trace_notes (struct target_ops
*self
,
11784 const char *user
, const char *notes
,
11785 const char *stop_notes
)
11787 struct remote_state
*rs
= get_remote_state ();
11789 char *buf
= rs
->buf
;
11790 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11793 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
11796 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
11797 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
11803 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
11804 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
11810 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
11811 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
11815 /* Ensure the buffer is terminated. */
11819 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11820 if (*reply
== '\0')
11823 if (strcmp (reply
, "OK") != 0)
11824 error (_("Bogus reply from target: %s"), reply
);
11830 remote_use_agent (struct target_ops
*self
, int use
)
11832 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
11834 struct remote_state
*rs
= get_remote_state ();
11836 /* If the stub supports QAgent. */
11837 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
11839 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11841 if (strcmp (rs
->buf
, "OK") == 0)
11852 remote_can_use_agent (struct target_ops
*self
)
11854 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
11857 struct btrace_target_info
11859 /* The ptid of the traced thread. */
11862 /* The obtained branch trace configuration. */
11863 struct btrace_config conf
;
11866 /* Reset our idea of our target's btrace configuration. */
11869 remote_btrace_reset (void)
11871 struct remote_state
*rs
= get_remote_state ();
11873 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
11876 /* Check whether the target supports branch tracing. */
11879 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
11881 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
11883 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
11888 case BTRACE_FORMAT_NONE
:
11891 case BTRACE_FORMAT_BTS
:
11892 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
11894 case BTRACE_FORMAT_PT
:
11895 /* The trace is decoded on the host. Even if our target supports it,
11896 we still need to have libipt to decode the trace. */
11897 #if defined (HAVE_LIBIPT)
11898 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
11899 #else /* !defined (HAVE_LIBIPT) */
11901 #endif /* !defined (HAVE_LIBIPT) */
11904 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
11907 /* Synchronize the configuration with the target. */
11910 btrace_sync_conf (const struct btrace_config
*conf
)
11912 struct packet_config
*packet
;
11913 struct remote_state
*rs
;
11914 char *buf
, *pos
, *endbuf
;
11916 rs
= get_remote_state ();
11918 endbuf
= buf
+ get_remote_packet_size ();
11920 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
11921 if (packet_config_support (packet
) == PACKET_ENABLE
11922 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
11925 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
11929 getpkt (&buf
, &rs
->buf_size
, 0);
11931 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
11933 if (buf
[0] == 'E' && buf
[1] == '.')
11934 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
11936 error (_("Failed to configure the BTS buffer size."));
11939 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
11942 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
11943 if (packet_config_support (packet
) == PACKET_ENABLE
11944 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
11947 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
11951 getpkt (&buf
, &rs
->buf_size
, 0);
11953 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
11955 if (buf
[0] == 'E' && buf
[1] == '.')
11956 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
11958 error (_("Failed to configure the trace buffer size."));
11961 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
11965 /* Read the current thread's btrace configuration from the target and
11966 store it into CONF. */
11969 btrace_read_config (struct btrace_config
*conf
)
11973 xml
= target_read_stralloc (¤t_target
,
11974 TARGET_OBJECT_BTRACE_CONF
, "");
11977 struct cleanup
*cleanup
;
11979 cleanup
= make_cleanup (xfree
, xml
);
11980 parse_xml_btrace_conf (conf
, xml
);
11981 do_cleanups (cleanup
);
11985 /* Enable branch tracing. */
11987 static struct btrace_target_info
*
11988 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
11989 const struct btrace_config
*conf
)
11991 struct btrace_target_info
*tinfo
= NULL
;
11992 struct packet_config
*packet
= NULL
;
11993 struct remote_state
*rs
= get_remote_state ();
11994 char *buf
= rs
->buf
;
11995 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11997 switch (conf
->format
)
11999 case BTRACE_FORMAT_BTS
:
12000 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
12003 case BTRACE_FORMAT_PT
:
12004 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
12008 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
12009 error (_("Target does not support branch tracing."));
12011 btrace_sync_conf (conf
);
12013 set_general_thread (ptid
);
12015 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
12017 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12019 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
12021 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
12022 error (_("Could not enable branch tracing for %s: %s"),
12023 target_pid_to_str (ptid
), rs
->buf
+ 2);
12025 error (_("Could not enable branch tracing for %s."),
12026 target_pid_to_str (ptid
));
12029 tinfo
= xzalloc (sizeof (*tinfo
));
12030 tinfo
->ptid
= ptid
;
12032 /* If we fail to read the configuration, we lose some information, but the
12033 tracing itself is not impacted. */
12036 btrace_read_config (&tinfo
->conf
);
12038 CATCH (err
, RETURN_MASK_ERROR
)
12040 if (err
.message
!= NULL
)
12041 warning ("%s", err
.message
);
12048 /* Disable branch tracing. */
12051 remote_disable_btrace (struct target_ops
*self
,
12052 struct btrace_target_info
*tinfo
)
12054 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
12055 struct remote_state
*rs
= get_remote_state ();
12056 char *buf
= rs
->buf
;
12057 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12059 if (packet_config_support (packet
) != PACKET_ENABLE
)
12060 error (_("Target does not support branch tracing."));
12062 set_general_thread (tinfo
->ptid
);
12064 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
12066 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12068 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
12070 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
12071 error (_("Could not disable branch tracing for %s: %s"),
12072 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
12074 error (_("Could not disable branch tracing for %s."),
12075 target_pid_to_str (tinfo
->ptid
));
12081 /* Teardown branch tracing. */
12084 remote_teardown_btrace (struct target_ops
*self
,
12085 struct btrace_target_info
*tinfo
)
12087 /* We must not talk to the target during teardown. */
12091 /* Read the branch trace. */
12093 static enum btrace_error
12094 remote_read_btrace (struct target_ops
*self
,
12095 struct btrace_data
*btrace
,
12096 struct btrace_target_info
*tinfo
,
12097 enum btrace_read_type type
)
12099 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
12100 struct remote_state
*rs
= get_remote_state ();
12101 struct cleanup
*cleanup
;
12105 if (packet_config_support (packet
) != PACKET_ENABLE
)
12106 error (_("Target does not support branch tracing."));
12108 #if !defined(HAVE_LIBEXPAT)
12109 error (_("Cannot process branch tracing result. XML parsing not supported."));
12114 case BTRACE_READ_ALL
:
12117 case BTRACE_READ_NEW
:
12120 case BTRACE_READ_DELTA
:
12124 internal_error (__FILE__
, __LINE__
,
12125 _("Bad branch tracing read type: %u."),
12126 (unsigned int) type
);
12129 xml
= target_read_stralloc (¤t_target
,
12130 TARGET_OBJECT_BTRACE
, annex
);
12132 return BTRACE_ERR_UNKNOWN
;
12134 cleanup
= make_cleanup (xfree
, xml
);
12135 parse_xml_btrace (btrace
, xml
);
12136 do_cleanups (cleanup
);
12138 return BTRACE_ERR_NONE
;
12141 static const struct btrace_config
*
12142 remote_btrace_conf (struct target_ops
*self
,
12143 const struct btrace_target_info
*tinfo
)
12145 return &tinfo
->conf
;
12149 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
12151 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
12155 /* Implementation of to_load. */
12158 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
12160 generic_load (name
, from_tty
);
12163 /* Accepts an integer PID; returns a string representing a file that
12164 can be opened on the remote side to get the symbols for the child
12165 process. Returns NULL if the operation is not supported. */
12168 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
12170 static char *filename
= NULL
;
12171 struct inferior
*inf
;
12172 char *annex
= NULL
;
12174 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
12177 if (filename
!= NULL
)
12180 inf
= find_inferior_pid (pid
);
12182 internal_error (__FILE__
, __LINE__
,
12183 _("not currently attached to process %d"), pid
);
12185 if (!inf
->fake_pid_p
)
12187 const int annex_size
= 9;
12189 annex
= alloca (annex_size
);
12190 xsnprintf (annex
, annex_size
, "%x", pid
);
12193 filename
= target_read_stralloc (¤t_target
,
12194 TARGET_OBJECT_EXEC_FILE
, annex
);
12200 init_remote_ops (void)
12202 remote_ops
.to_shortname
= "remote";
12203 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
12204 remote_ops
.to_doc
=
12205 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
12206 Specify the serial device it is connected to\n\
12207 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
12208 remote_ops
.to_open
= remote_open
;
12209 remote_ops
.to_close
= remote_close
;
12210 remote_ops
.to_detach
= remote_detach
;
12211 remote_ops
.to_disconnect
= remote_disconnect
;
12212 remote_ops
.to_resume
= remote_resume
;
12213 remote_ops
.to_wait
= remote_wait
;
12214 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
12215 remote_ops
.to_store_registers
= remote_store_registers
;
12216 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
12217 remote_ops
.to_files_info
= remote_files_info
;
12218 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
12219 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
12220 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
12221 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
12222 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
12223 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
12224 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
12225 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
12226 remote_ops
.to_watchpoint_addr_within_range
=
12227 remote_watchpoint_addr_within_range
;
12228 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
12229 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
12230 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
12231 remote_ops
.to_region_ok_for_hw_watchpoint
12232 = remote_region_ok_for_hw_watchpoint
;
12233 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
12234 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
12235 remote_ops
.to_kill
= remote_kill
;
12236 remote_ops
.to_load
= remote_load
;
12237 remote_ops
.to_mourn_inferior
= remote_mourn
;
12238 remote_ops
.to_pass_signals
= remote_pass_signals
;
12239 remote_ops
.to_program_signals
= remote_program_signals
;
12240 remote_ops
.to_thread_alive
= remote_thread_alive
;
12241 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
12242 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
12243 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
12244 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
12245 remote_ops
.to_stop
= remote_stop
;
12246 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
12247 remote_ops
.to_rcmd
= remote_rcmd
;
12248 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
12249 remote_ops
.to_log_command
= serial_log_command
;
12250 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
12251 remote_ops
.to_stratum
= process_stratum
;
12252 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
12253 remote_ops
.to_has_memory
= default_child_has_memory
;
12254 remote_ops
.to_has_stack
= default_child_has_stack
;
12255 remote_ops
.to_has_registers
= default_child_has_registers
;
12256 remote_ops
.to_has_execution
= default_child_has_execution
;
12257 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
12258 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
12259 remote_ops
.to_magic
= OPS_MAGIC
;
12260 remote_ops
.to_memory_map
= remote_memory_map
;
12261 remote_ops
.to_flash_erase
= remote_flash_erase
;
12262 remote_ops
.to_flash_done
= remote_flash_done
;
12263 remote_ops
.to_read_description
= remote_read_description
;
12264 remote_ops
.to_search_memory
= remote_search_memory
;
12265 remote_ops
.to_can_async_p
= remote_can_async_p
;
12266 remote_ops
.to_is_async_p
= remote_is_async_p
;
12267 remote_ops
.to_async
= remote_async
;
12268 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
12269 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
12270 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
12271 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
12272 remote_ops
.to_supports_disable_randomization
12273 = remote_supports_disable_randomization
;
12274 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
12275 remote_ops
.to_fileio_open
= remote_hostio_open
;
12276 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
12277 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
12278 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
12279 remote_ops
.to_fileio_close
= remote_hostio_close
;
12280 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
12281 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
12282 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
12283 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
12284 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
12285 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
12286 remote_ops
.to_trace_init
= remote_trace_init
;
12287 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
12288 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
12289 remote_ops
.to_download_trace_state_variable
12290 = remote_download_trace_state_variable
;
12291 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
12292 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
12293 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
12294 remote_ops
.to_trace_start
= remote_trace_start
;
12295 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
12296 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
12297 remote_ops
.to_trace_stop
= remote_trace_stop
;
12298 remote_ops
.to_trace_find
= remote_trace_find
;
12299 remote_ops
.to_get_trace_state_variable_value
12300 = remote_get_trace_state_variable_value
;
12301 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
12302 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
12303 remote_ops
.to_upload_trace_state_variables
12304 = remote_upload_trace_state_variables
;
12305 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
12306 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
12307 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
12308 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
12309 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
12310 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
12311 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
12312 remote_ops
.to_verify_memory
= remote_verify_memory
;
12313 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
12314 remote_ops
.to_set_permissions
= remote_set_permissions
;
12315 remote_ops
.to_static_tracepoint_marker_at
12316 = remote_static_tracepoint_marker_at
;
12317 remote_ops
.to_static_tracepoint_markers_by_strid
12318 = remote_static_tracepoint_markers_by_strid
;
12319 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
12320 remote_ops
.to_use_agent
= remote_use_agent
;
12321 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
12322 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
12323 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
12324 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
12325 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
12326 remote_ops
.to_read_btrace
= remote_read_btrace
;
12327 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
12328 remote_ops
.to_augmented_libraries_svr4_read
=
12329 remote_augmented_libraries_svr4_read
;
12332 /* Set up the extended remote vector by making a copy of the standard
12333 remote vector and adding to it. */
12336 init_extended_remote_ops (void)
12338 extended_remote_ops
= remote_ops
;
12340 extended_remote_ops
.to_shortname
= "extended-remote";
12341 extended_remote_ops
.to_longname
=
12342 "Extended remote serial target in gdb-specific protocol";
12343 extended_remote_ops
.to_doc
=
12344 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
12345 Specify the serial device it is connected to (e.g. /dev/ttya).";
12346 extended_remote_ops
.to_open
= extended_remote_open
;
12347 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
12348 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
12349 extended_remote_ops
.to_detach
= extended_remote_detach
;
12350 extended_remote_ops
.to_attach
= extended_remote_attach
;
12351 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
12352 extended_remote_ops
.to_kill
= extended_remote_kill
;
12353 extended_remote_ops
.to_supports_disable_randomization
12354 = extended_remote_supports_disable_randomization
;
12355 extended_remote_ops
.to_follow_fork
= remote_follow_fork
;
12356 extended_remote_ops
.to_insert_fork_catchpoint
12357 = remote_insert_fork_catchpoint
;
12358 extended_remote_ops
.to_remove_fork_catchpoint
12359 = remote_remove_fork_catchpoint
;
12360 extended_remote_ops
.to_insert_vfork_catchpoint
12361 = remote_insert_vfork_catchpoint
;
12362 extended_remote_ops
.to_remove_vfork_catchpoint
12363 = remote_remove_vfork_catchpoint
;
12367 remote_can_async_p (struct target_ops
*ops
)
12369 struct remote_state
*rs
= get_remote_state ();
12371 if (!target_async_permitted
)
12372 /* We only enable async when the user specifically asks for it. */
12375 /* We're async whenever the serial device is. */
12376 return serial_can_async_p (rs
->remote_desc
);
12380 remote_is_async_p (struct target_ops
*ops
)
12382 struct remote_state
*rs
= get_remote_state ();
12384 if (!target_async_permitted
)
12385 /* We only enable async when the user specifically asks for it. */
12388 /* We're async whenever the serial device is. */
12389 return serial_is_async_p (rs
->remote_desc
);
12392 /* Pass the SERIAL event on and up to the client. One day this code
12393 will be able to delay notifying the client of an event until the
12394 point where an entire packet has been received. */
12396 static serial_event_ftype remote_async_serial_handler
;
12399 remote_async_serial_handler (struct serial
*scb
, void *context
)
12401 struct remote_state
*rs
= context
;
12403 /* Don't propogate error information up to the client. Instead let
12404 the client find out about the error by querying the target. */
12405 inferior_event_handler (INF_REG_EVENT
, NULL
);
12409 remote_async_inferior_event_handler (gdb_client_data data
)
12411 inferior_event_handler (INF_REG_EVENT
, NULL
);
12415 remote_async (struct target_ops
*ops
, int enable
)
12417 struct remote_state
*rs
= get_remote_state ();
12421 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
12423 /* If there are pending events in the stop reply queue tell the
12424 event loop to process them. */
12425 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
12426 mark_async_event_handler (remote_async_inferior_event_token
);
12430 serial_async (rs
->remote_desc
, NULL
, NULL
);
12431 clear_async_event_handler (remote_async_inferior_event_token
);
12436 set_remote_cmd (char *args
, int from_tty
)
12438 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
12442 show_remote_cmd (char *args
, int from_tty
)
12444 /* We can't just use cmd_show_list here, because we want to skip
12445 the redundant "show remote Z-packet" and the legacy aliases. */
12446 struct cleanup
*showlist_chain
;
12447 struct cmd_list_element
*list
= remote_show_cmdlist
;
12448 struct ui_out
*uiout
= current_uiout
;
12450 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
12451 for (; list
!= NULL
; list
= list
->next
)
12452 if (strcmp (list
->name
, "Z-packet") == 0)
12454 else if (list
->type
== not_set_cmd
)
12455 /* Alias commands are exactly like the original, except they
12456 don't have the normal type. */
12460 struct cleanup
*option_chain
12461 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
12463 ui_out_field_string (uiout
, "name", list
->name
);
12464 ui_out_text (uiout
, ": ");
12465 if (list
->type
== show_cmd
)
12466 do_show_command ((char *) NULL
, from_tty
, list
);
12468 cmd_func (list
, NULL
, from_tty
);
12469 /* Close the tuple. */
12470 do_cleanups (option_chain
);
12473 /* Close the tuple. */
12474 do_cleanups (showlist_chain
);
12478 /* Function to be called whenever a new objfile (shlib) is detected. */
12480 remote_new_objfile (struct objfile
*objfile
)
12482 struct remote_state
*rs
= get_remote_state ();
12484 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
12485 remote_check_symbols ();
12488 /* Pull all the tracepoints defined on the target and create local
12489 data structures representing them. We don't want to create real
12490 tracepoints yet, we don't want to mess up the user's existing
12494 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
12496 struct remote_state
*rs
= get_remote_state ();
12499 /* Ask for a first packet of tracepoint definition. */
12501 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12503 while (*p
&& *p
!= 'l')
12505 parse_tracepoint_definition (p
, utpp
);
12506 /* Ask for another packet of tracepoint definition. */
12508 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12515 remote_upload_trace_state_variables (struct target_ops
*self
,
12516 struct uploaded_tsv
**utsvp
)
12518 struct remote_state
*rs
= get_remote_state ();
12521 /* Ask for a first packet of variable definition. */
12523 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12525 while (*p
&& *p
!= 'l')
12527 parse_tsv_definition (p
, utsvp
);
12528 /* Ask for another packet of variable definition. */
12530 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12536 /* The "set/show range-stepping" show hook. */
12539 show_range_stepping (struct ui_file
*file
, int from_tty
,
12540 struct cmd_list_element
*c
,
12543 fprintf_filtered (file
,
12544 _("Debugger's willingness to use range stepping "
12545 "is %s.\n"), value
);
12548 /* The "set/show range-stepping" set hook. */
12551 set_range_stepping (char *ignore_args
, int from_tty
,
12552 struct cmd_list_element
*c
)
12554 struct remote_state
*rs
= get_remote_state ();
12556 /* Whene enabling, check whether range stepping is actually
12557 supported by the target, and warn if not. */
12558 if (use_range_stepping
)
12560 if (rs
->remote_desc
!= NULL
)
12562 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
12563 remote_vcont_probe (rs
);
12565 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
12566 && rs
->supports_vCont
.r
)
12570 warning (_("Range stepping is not supported by the current target"));
12575 _initialize_remote (void)
12577 struct remote_state
*rs
;
12578 struct cmd_list_element
*cmd
;
12579 const char *cmd_name
;
12581 /* architecture specific data */
12582 remote_gdbarch_data_handle
=
12583 gdbarch_data_register_post_init (init_remote_state
);
12584 remote_g_packet_data_handle
=
12585 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
12587 /* Initialize the per-target state. At the moment there is only one
12588 of these, not one per target. Only one target is active at a
12590 remote_state
= new_remote_state ();
12592 init_remote_ops ();
12593 add_target (&remote_ops
);
12595 init_extended_remote_ops ();
12596 add_target (&extended_remote_ops
);
12598 /* Hook into new objfile notification. */
12599 observer_attach_new_objfile (remote_new_objfile
);
12600 /* We're no longer interested in notification events of an inferior
12602 observer_attach_inferior_exit (discard_pending_stop_replies
);
12604 /* Set up signal handlers. */
12605 async_sigint_remote_token
=
12606 create_async_signal_handler (async_remote_interrupt
, NULL
);
12607 async_sigint_remote_twice_token
=
12608 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
12611 init_remote_threadtests ();
12614 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
12615 /* set/show remote ... */
12617 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
12618 Remote protocol specific variables\n\
12619 Configure various remote-protocol specific variables such as\n\
12620 the packets being used"),
12621 &remote_set_cmdlist
, "set remote ",
12622 0 /* allow-unknown */, &setlist
);
12623 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
12624 Remote protocol specific variables\n\
12625 Configure various remote-protocol specific variables such as\n\
12626 the packets being used"),
12627 &remote_show_cmdlist
, "show remote ",
12628 0 /* allow-unknown */, &showlist
);
12630 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
12631 Compare section data on target to the exec file.\n\
12632 Argument is a single section name (default: all loaded sections).\n\
12633 To compare only read-only loaded sections, specify the -r option."),
12636 add_cmd ("packet", class_maintenance
, packet_command
, _("\
12637 Send an arbitrary packet to a remote target.\n\
12638 maintenance packet TEXT\n\
12639 If GDB is talking to an inferior via the GDB serial protocol, then\n\
12640 this command sends the string TEXT to the inferior, and displays the\n\
12641 response packet. GDB supplies the initial `$' character, and the\n\
12642 terminating `#' character and checksum."),
12645 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
12646 Set whether to send break if interrupted."), _("\
12647 Show whether to send break if interrupted."), _("\
12648 If set, a break, instead of a cntrl-c, is sent to the remote target."),
12649 set_remotebreak
, show_remotebreak
,
12650 &setlist
, &showlist
);
12651 cmd_name
= "remotebreak";
12652 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
12653 deprecate_cmd (cmd
, "set remote interrupt-sequence");
12654 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
12655 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
12656 deprecate_cmd (cmd
, "show remote interrupt-sequence");
12658 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
12659 interrupt_sequence_modes
, &interrupt_sequence_mode
,
12661 Set interrupt sequence to remote target."), _("\
12662 Show interrupt sequence to remote target."), _("\
12663 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
12664 NULL
, show_interrupt_sequence
,
12665 &remote_set_cmdlist
,
12666 &remote_show_cmdlist
);
12668 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
12669 &interrupt_on_connect
, _("\
12670 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
12671 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
12672 If set, interrupt sequence is sent to remote target."),
12674 &remote_set_cmdlist
, &remote_show_cmdlist
);
12676 /* Install commands for configuring memory read/write packets. */
12678 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
12679 Set the maximum number of bytes per memory write packet (deprecated)."),
12681 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
12682 Show the maximum number of bytes per memory write packet (deprecated)."),
12684 add_cmd ("memory-write-packet-size", no_class
,
12685 set_memory_write_packet_size
, _("\
12686 Set the maximum number of bytes per memory-write packet.\n\
12687 Specify the number of bytes in a packet or 0 (zero) for the\n\
12688 default packet size. The actual limit is further reduced\n\
12689 dependent on the target. Specify ``fixed'' to disable the\n\
12690 further restriction and ``limit'' to enable that restriction."),
12691 &remote_set_cmdlist
);
12692 add_cmd ("memory-read-packet-size", no_class
,
12693 set_memory_read_packet_size
, _("\
12694 Set the maximum number of bytes per memory-read packet.\n\
12695 Specify the number of bytes in a packet or 0 (zero) for the\n\
12696 default packet size. The actual limit is further reduced\n\
12697 dependent on the target. Specify ``fixed'' to disable the\n\
12698 further restriction and ``limit'' to enable that restriction."),
12699 &remote_set_cmdlist
);
12700 add_cmd ("memory-write-packet-size", no_class
,
12701 show_memory_write_packet_size
,
12702 _("Show the maximum number of bytes per memory-write packet."),
12703 &remote_show_cmdlist
);
12704 add_cmd ("memory-read-packet-size", no_class
,
12705 show_memory_read_packet_size
,
12706 _("Show the maximum number of bytes per memory-read packet."),
12707 &remote_show_cmdlist
);
12709 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
12710 &remote_hw_watchpoint_limit
, _("\
12711 Set the maximum number of target hardware watchpoints."), _("\
12712 Show the maximum number of target hardware watchpoints."), _("\
12713 Specify a negative limit for unlimited."),
12714 NULL
, NULL
, /* FIXME: i18n: The maximum
12715 number of target hardware
12716 watchpoints is %s. */
12717 &remote_set_cmdlist
, &remote_show_cmdlist
);
12718 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
12719 &remote_hw_watchpoint_length_limit
, _("\
12720 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
12721 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
12722 Specify a negative limit for unlimited."),
12723 NULL
, NULL
, /* FIXME: i18n: The maximum
12724 length (in bytes) of a target
12725 hardware watchpoint is %s. */
12726 &remote_set_cmdlist
, &remote_show_cmdlist
);
12727 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
12728 &remote_hw_breakpoint_limit
, _("\
12729 Set the maximum number of target hardware breakpoints."), _("\
12730 Show the maximum number of target hardware breakpoints."), _("\
12731 Specify a negative limit for unlimited."),
12732 NULL
, NULL
, /* FIXME: i18n: The maximum
12733 number of target hardware
12734 breakpoints is %s. */
12735 &remote_set_cmdlist
, &remote_show_cmdlist
);
12737 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
12738 &remote_address_size
, _("\
12739 Set the maximum size of the address (in bits) in a memory packet."), _("\
12740 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
12742 NULL
, /* FIXME: i18n: */
12743 &setlist
, &showlist
);
12745 init_all_packet_configs ();
12747 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
12748 "X", "binary-download", 1);
12750 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
12751 "vCont", "verbose-resume", 0);
12753 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
12754 "QPassSignals", "pass-signals", 0);
12756 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
12757 "QProgramSignals", "program-signals", 0);
12759 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
12760 "qSymbol", "symbol-lookup", 0);
12762 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
12763 "P", "set-register", 1);
12765 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
12766 "p", "fetch-register", 1);
12768 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
12769 "Z0", "software-breakpoint", 0);
12771 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
12772 "Z1", "hardware-breakpoint", 0);
12774 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
12775 "Z2", "write-watchpoint", 0);
12777 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
12778 "Z3", "read-watchpoint", 0);
12780 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
12781 "Z4", "access-watchpoint", 0);
12783 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
12784 "qXfer:auxv:read", "read-aux-vector", 0);
12786 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
12787 "qXfer:exec-file:read", "pid-to-exec-file", 0);
12789 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
12790 "qXfer:features:read", "target-features", 0);
12792 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
12793 "qXfer:libraries:read", "library-info", 0);
12795 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
12796 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
12798 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
12799 "qXfer:memory-map:read", "memory-map", 0);
12801 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
12802 "qXfer:spu:read", "read-spu-object", 0);
12804 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
12805 "qXfer:spu:write", "write-spu-object", 0);
12807 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
12808 "qXfer:osdata:read", "osdata", 0);
12810 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
12811 "qXfer:threads:read", "threads", 0);
12813 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
12814 "qXfer:siginfo:read", "read-siginfo-object", 0);
12816 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
12817 "qXfer:siginfo:write", "write-siginfo-object", 0);
12819 add_packet_config_cmd
12820 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
12821 "qXfer:traceframe-info:read", "traceframe-info", 0);
12823 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
12824 "qXfer:uib:read", "unwind-info-block", 0);
12826 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
12827 "qGetTLSAddr", "get-thread-local-storage-address",
12830 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
12831 "qGetTIBAddr", "get-thread-information-block-address",
12834 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
12835 "bc", "reverse-continue", 0);
12837 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
12838 "bs", "reverse-step", 0);
12840 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
12841 "qSupported", "supported-packets", 0);
12843 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
12844 "qSearch:memory", "search-memory", 0);
12846 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
12847 "qTStatus", "trace-status", 0);
12849 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
12850 "vFile:setfs", "hostio-setfs", 0);
12852 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
12853 "vFile:open", "hostio-open", 0);
12855 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
12856 "vFile:pread", "hostio-pread", 0);
12858 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
12859 "vFile:pwrite", "hostio-pwrite", 0);
12861 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
12862 "vFile:close", "hostio-close", 0);
12864 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
12865 "vFile:unlink", "hostio-unlink", 0);
12867 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
12868 "vFile:readlink", "hostio-readlink", 0);
12870 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
12871 "vFile:fstat", "hostio-fstat", 0);
12873 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
12874 "vAttach", "attach", 0);
12876 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
12879 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
12880 "QStartNoAckMode", "noack", 0);
12882 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
12883 "vKill", "kill", 0);
12885 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
12886 "qAttached", "query-attached", 0);
12888 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
12889 "ConditionalTracepoints",
12890 "conditional-tracepoints", 0);
12892 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
12893 "ConditionalBreakpoints",
12894 "conditional-breakpoints", 0);
12896 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
12897 "BreakpointCommands",
12898 "breakpoint-commands", 0);
12900 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
12901 "FastTracepoints", "fast-tracepoints", 0);
12903 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
12904 "TracepointSource", "TracepointSource", 0);
12906 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
12907 "QAllow", "allow", 0);
12909 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
12910 "StaticTracepoints", "static-tracepoints", 0);
12912 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
12913 "InstallInTrace", "install-in-trace", 0);
12915 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
12916 "qXfer:statictrace:read", "read-sdata-object", 0);
12918 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
12919 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
12921 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
12922 "QDisableRandomization", "disable-randomization", 0);
12924 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
12925 "QAgent", "agent", 0);
12927 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
12928 "QTBuffer:size", "trace-buffer-size", 0);
12930 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
12931 "Qbtrace:off", "disable-btrace", 0);
12933 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
12934 "Qbtrace:bts", "enable-btrace-bts", 0);
12936 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
12937 "Qbtrace:pt", "enable-btrace-pt", 0);
12939 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
12940 "qXfer:btrace", "read-btrace", 0);
12942 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
12943 "qXfer:btrace-conf", "read-btrace-conf", 0);
12945 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
12946 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
12948 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
12949 "swbreak-feature", "swbreak-feature", 0);
12951 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
12952 "hwbreak-feature", "hwbreak-feature", 0);
12954 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
12955 "fork-event-feature", "fork-event-feature", 0);
12957 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
12958 "vfork-event-feature", "vfork-event-feature", 0);
12960 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
12961 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
12963 /* Assert that we've registered "set remote foo-packet" commands
12964 for all packet configs. */
12968 for (i
= 0; i
< PACKET_MAX
; i
++)
12970 /* Ideally all configs would have a command associated. Some
12971 still don't though. */
12976 case PACKET_QNonStop
:
12977 case PACKET_multiprocess_feature
:
12978 case PACKET_EnableDisableTracepoints_feature
:
12979 case PACKET_tracenz_feature
:
12980 case PACKET_DisconnectedTracing_feature
:
12981 case PACKET_augmented_libraries_svr4_read_feature
:
12983 /* Additions to this list need to be well justified:
12984 pre-existing packets are OK; new packets are not. */
12992 /* This catches both forgetting to add a config command, and
12993 forgetting to remove a packet from the exception list. */
12994 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
12998 /* Keep the old ``set remote Z-packet ...'' working. Each individual
12999 Z sub-packet has its own set and show commands, but users may
13000 have sets to this variable in their .gdbinit files (or in their
13002 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
13003 &remote_Z_packet_detect
, _("\
13004 Set use of remote protocol `Z' packets"), _("\
13005 Show use of remote protocol `Z' packets "), _("\
13006 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
13008 set_remote_protocol_Z_packet_cmd
,
13009 show_remote_protocol_Z_packet_cmd
,
13010 /* FIXME: i18n: Use of remote protocol
13011 `Z' packets is %s. */
13012 &remote_set_cmdlist
, &remote_show_cmdlist
);
13014 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
13015 Manipulate files on the remote system\n\
13016 Transfer files to and from the remote target system."),
13017 &remote_cmdlist
, "remote ",
13018 0 /* allow-unknown */, &cmdlist
);
13020 add_cmd ("put", class_files
, remote_put_command
,
13021 _("Copy a local file to the remote system."),
13024 add_cmd ("get", class_files
, remote_get_command
,
13025 _("Copy a remote file to the local system."),
13028 add_cmd ("delete", class_files
, remote_delete_command
,
13029 _("Delete a remote file."),
13032 remote_exec_file
= xstrdup ("");
13033 add_setshow_string_noescape_cmd ("exec-file", class_files
,
13034 &remote_exec_file
, _("\
13035 Set the remote pathname for \"run\""), _("\
13036 Show the remote pathname for \"run\""), NULL
, NULL
, NULL
,
13037 &remote_set_cmdlist
, &remote_show_cmdlist
);
13039 add_setshow_boolean_cmd ("range-stepping", class_run
,
13040 &use_range_stepping
, _("\
13041 Enable or disable range stepping."), _("\
13042 Show whether target-assisted range stepping is enabled."), _("\
13043 If on, and the target supports it, when stepping a source line, GDB\n\
13044 tells the target to step the corresponding range of addresses itself instead\n\
13045 of issuing multiple single-steps. This speeds up source level\n\
13046 stepping. If off, GDB always issues single-steps, even if range\n\
13047 stepping is supported by the target. The default is on."),
13048 set_range_stepping
,
13049 show_range_stepping
,
13053 /* Eventually initialize fileio. See fileio.c */
13054 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
13056 /* Take advantage of the fact that the TID field is not used, to tag
13057 special ptids with it set to != 0. */
13058 magic_null_ptid
= ptid_build (42000, -1, 1);
13059 not_sent_ptid
= ptid_build (42000, -2, 1);
13060 any_thread_ptid
= ptid_build (42000, 0, 1);
13062 target_buf_size
= 2048;
13063 target_buf
= xmalloc (target_buf_size
);