1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
5 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* See the GDB User Guide for details of the GDB remote protocol. */
25 #include "gdb_string.h"
31 #include "exceptions.h"
33 /*#include "terminal.h" */
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
41 #include "gdb_assert.h"
44 #include "cli/cli-decode.h"
45 #include "cli/cli-setshow.h"
46 #include "target-descriptions.h"
51 #include "event-loop.h"
52 #include "event-top.h"
58 #include "gdbcore.h" /* for exec_bfd */
60 #include "remote-fileio.h"
61 #include "gdb/fileio.h"
63 #include "xml-support.h"
65 #include "memory-map.h"
67 #include "tracepoint.h"
71 /* Temp hacks for tracepoint encoding migration. */
72 static char *target_buf;
73 static long target_buf_size;
75 encode_actions (struct breakpoint *t, struct bp_location *tloc,
76 char ***tdp_actions, char ***stepping_actions);
78 /* The size to align memory write packets, when practical. The protocol
79 does not guarantee any alignment, and gdb will generate short
80 writes and unaligned writes, but even as a best-effort attempt this
81 can improve bulk transfers. For instance, if a write is misaligned
82 relative to the target's data bus, the stub may need to make an extra
83 round trip fetching data from the target. This doesn't make a
84 huge difference, but it's easy to do, so we try to be helpful.
86 The alignment chosen is arbitrary; usually data bus width is
87 important here, not the possibly larger cache line size. */
88 enum { REMOTE_ALIGN_WRITES = 16 };
90 /* Prototypes for local functions. */
91 static void cleanup_sigint_signal_handler (void *dummy);
92 static void initialize_sigint_signal_handler (void);
93 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
94 static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
97 static void handle_remote_sigint (int);
98 static void handle_remote_sigint_twice (int);
99 static void async_remote_interrupt (gdb_client_data);
100 void async_remote_interrupt_twice (gdb_client_data);
102 static void remote_files_info (struct target_ops *ignore);
104 static void remote_prepare_to_store (struct regcache *regcache);
106 static void remote_open (char *name, int from_tty);
108 static void extended_remote_open (char *name, int from_tty);
110 static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
112 static void remote_close (int quitting);
114 static void remote_mourn (struct target_ops *ops);
116 static void extended_remote_restart (void);
118 static void extended_remote_mourn (struct target_ops *);
120 static void remote_mourn_1 (struct target_ops *);
122 static void remote_send (char **buf, long *sizeof_buf_p);
124 static int readchar (int timeout);
126 static void remote_kill (struct target_ops *ops);
128 static int tohex (int nib);
130 static int remote_can_async_p (void);
132 static int remote_is_async_p (void);
134 static void remote_async (void (*callback) (enum inferior_event_type event_type,
135 void *context), void *context);
137 static int remote_async_mask (int new_mask);
139 static void remote_detach (struct target_ops *ops, char *args, int from_tty);
141 static void remote_interrupt (int signo);
143 static void remote_interrupt_twice (int signo);
145 static void interrupt_query (void);
147 static void set_general_thread (struct ptid ptid);
148 static void set_continue_thread (struct ptid ptid);
150 static void get_offsets (void);
152 static void skip_frame (void);
154 static long read_frame (char **buf_p, long *sizeof_buf);
156 static int hexnumlen (ULONGEST num);
158 static void init_remote_ops (void);
160 static void init_extended_remote_ops (void);
162 static void remote_stop (ptid_t);
164 static int ishex (int ch, int *val);
166 static int stubhex (int ch);
168 static int hexnumstr (char *, ULONGEST);
170 static int hexnumnstr (char *, ULONGEST, int);
172 static CORE_ADDR remote_address_masked (CORE_ADDR);
174 static void print_packet (char *);
176 static void compare_sections_command (char *, int);
178 static void packet_command (char *, int);
180 static int stub_unpack_int (char *buff, int fieldlength);
182 static ptid_t remote_current_thread (ptid_t oldptid);
184 static void remote_find_new_threads (void);
186 static void record_currthread (ptid_t currthread);
188 static int fromhex (int a);
190 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
192 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
194 static int putpkt_binary (char *buf, int cnt);
196 static void check_binary_download (CORE_ADDR addr);
198 struct packet_config;
200 static void show_packet_config_cmd (struct packet_config *config);
202 static void update_packet_config (struct packet_config *config);
204 static void set_remote_protocol_packet_cmd (char *args, int from_tty,
205 struct cmd_list_element *c);
207 static void show_remote_protocol_packet_cmd (struct ui_file *file,
209 struct cmd_list_element *c,
212 static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
213 static ptid_t read_ptid (char *buf, char **obuf);
215 static void remote_set_permissions (void);
218 static int remote_get_trace_status (struct trace_status *ts);
220 static int remote_upload_tracepoints (struct uploaded_tp **utpp);
222 static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);
224 static void remote_query_supported (void);
226 static void remote_check_symbols (struct objfile *objfile);
228 void _initialize_remote (void);
231 static struct stop_reply *stop_reply_xmalloc (void);
232 static void stop_reply_xfree (struct stop_reply *);
233 static void do_stop_reply_xfree (void *arg);
234 static void remote_parse_stop_reply (char *buf, struct stop_reply *);
235 static void push_stop_reply (struct stop_reply *);
236 static void remote_get_pending_stop_replies (void);
237 static void discard_pending_stop_replies (int pid);
238 static int peek_stop_reply (ptid_t ptid);
240 static void remote_async_inferior_event_handler (gdb_client_data);
241 static void remote_async_get_pending_events_handler (gdb_client_data);
243 static void remote_terminal_ours (void);
245 static int remote_read_description_p (struct target_ops *target);
247 static void remote_console_output (char *msg);
249 /* The non-stop remote protocol provisions for one pending stop reply.
250 This is where we keep it until it is acknowledged. */
252 static struct stop_reply *pending_stop_reply = NULL;
256 static struct cmd_list_element *remote_cmdlist;
258 /* For "set remote" and "show remote". */
260 static struct cmd_list_element *remote_set_cmdlist;
261 static struct cmd_list_element *remote_show_cmdlist;
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 /* If we negotiated packet size explicitly (and thus can bypass
279 heuristics for the largest packet size that will not overflow
280 a buffer in the stub), this will be set to that packet size.
281 Otherwise zero, meaning to use the guessed size. */
282 long explicit_packet_size;
284 /* remote_wait is normally called when the target is running and
285 waits for a stop reply packet. But sometimes we need to call it
286 when the target is already stopped. We can send a "?" packet
287 and have remote_wait read the response. Or, if we already have
288 the response, we can stash it in BUF and tell remote_wait to
289 skip calling getpkt. This flag is set when BUF contains a
290 stop reply packet and the target is not waiting. */
291 int cached_wait_status;
293 /* True, if in no ack mode. That is, neither GDB nor the stub will
294 expect acks from each other. The connection is assumed to be
298 /* True if we're connected in extended remote mode. */
301 /* True if the stub reported support for multi-process
303 int multi_process_aware;
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 /* True if the stub reports support for non-stop mode. */
316 /* True if the stub reports support for vCont;t. */
319 /* True if the stub reports support for conditional tracepoints. */
320 int cond_tracepoints;
322 /* True if the stub reports support for fast tracepoints. */
323 int fast_tracepoints;
325 /* True if the stub reports support for static tracepoints. */
326 int static_tracepoints;
328 /* True if the stub can continue running a trace while GDB is
330 int disconnected_tracing;
332 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
333 responded to that. */
337 /* Private data that we'll store in (struct thread_info)->private. */
338 struct private_thread_info
345 free_private_thread_info (struct private_thread_info *info)
351 /* Returns true if the multi-process extensions are in effect. */
353 remote_multi_process_p (struct remote_state *rs)
355 return rs->extended && rs->multi_process_aware;
358 /* This data could be associated with a target, but we do not always
359 have access to the current target when we need it, so for now it is
360 static. This will be fine for as long as only one target is in use
362 static struct remote_state remote_state;
364 static struct remote_state *
365 get_remote_state_raw (void)
367 return &remote_state;
370 /* Description of the remote protocol for a given architecture. */
374 long offset; /* Offset into G packet. */
375 long regnum; /* GDB's internal register number. */
376 LONGEST pnum; /* Remote protocol register number. */
377 int in_g_packet; /* Always part of G packet. */
378 /* long size in bytes; == register_size (target_gdbarch, regnum);
380 /* char *name; == gdbarch_register_name (target_gdbarch, regnum);
384 struct remote_arch_state
386 /* Description of the remote protocol registers. */
387 long sizeof_g_packet;
389 /* Description of the remote protocol registers indexed by REGNUM
390 (making an array gdbarch_num_regs in size). */
391 struct packet_reg *regs;
393 /* This is the size (in chars) of the first response to the ``g''
394 packet. It is used as a heuristic when determining the maximum
395 size of memory-read and memory-write packets. A target will
396 typically only reserve a buffer large enough to hold the ``g''
397 packet. The size does not include packet overhead (headers and
399 long actual_register_packet_size;
401 /* This is the maximum size (in chars) of a non read/write packet.
402 It is also used as a cap on the size of read/write packets. */
403 long remote_packet_size;
406 long sizeof_pkt = 2000;
408 /* Utility: generate error from an incoming stub packet. */
410 trace_error (char *buf)
413 return; /* not an error msg */
416 case '1': /* malformed packet error */
417 if (*++buf == '0') /* general case: */
418 error (_("remote.c: error in outgoing packet."));
420 error (_("remote.c: error in outgoing packet at field #%ld."),
421 strtol (buf, NULL, 16));
423 error (_("trace API error 0x%s."), ++buf);
425 error (_("Target returns error code '%s'."), buf);
429 /* Utility: wait for reply from stub, while accepting "O" packets. */
431 remote_get_noisy_reply (char **buf_p,
434 do /* Loop on reply from remote stub. */
438 QUIT; /* Allow user to bail out with ^C. */
439 getpkt (buf_p, sizeof_buf, 0);
443 else if (strncmp (buf, "qRelocInsn:", strlen ("qRelocInsn:")) == 0)
446 CORE_ADDR from, to, org_to;
448 int adjusted_size = 0;
449 volatile struct gdb_exception ex;
451 p = buf + strlen ("qRelocInsn:");
452 pp = unpack_varlen_hex (p, &ul);
454 error (_("invalid qRelocInsn packet: %s"), buf);
458 pp = unpack_varlen_hex (p, &ul);
463 TRY_CATCH (ex, RETURN_MASK_ALL)
465 gdbarch_relocate_instruction (target_gdbarch, &to, from);
469 adjusted_size = to - org_to;
471 sprintf (buf, "qRelocInsn:%x", adjusted_size);
474 else if (ex.reason < 0 && ex.error == MEMORY_ERROR)
476 /* Propagate memory errors silently back to the target.
477 The stub may have limited the range of addresses we
478 can write to, for example. */
483 /* Something unexpectedly bad happened. Be verbose so
484 we can tell what, and propagate the error back to the
485 stub, so it doesn't get stuck waiting for a
487 exception_fprintf (gdb_stderr, ex,
488 _("warning: relocating instruction: "));
492 else if (buf[0] == 'O' && buf[1] != 'K')
493 remote_console_output (buf + 1); /* 'O' message from stub */
495 return buf; /* Here's the actual reply. */
500 /* Handle for retreving the remote protocol data from gdbarch. */
501 static struct gdbarch_data *remote_gdbarch_data_handle;
503 static struct remote_arch_state *
504 get_remote_arch_state (void)
506 return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle);
509 /* Fetch the global remote target state. */
511 static struct remote_state *
512 get_remote_state (void)
514 /* Make sure that the remote architecture state has been
515 initialized, because doing so might reallocate rs->buf. Any
516 function which calls getpkt also needs to be mindful of changes
517 to rs->buf, but this call limits the number of places which run
519 get_remote_arch_state ();
521 return get_remote_state_raw ();
525 compare_pnums (const void *lhs_, const void *rhs_)
527 const struct packet_reg * const *lhs = lhs_;
528 const struct packet_reg * const *rhs = rhs_;
530 if ((*lhs)->pnum < (*rhs)->pnum)
532 else if ((*lhs)->pnum == (*rhs)->pnum)
539 init_remote_state (struct gdbarch *gdbarch)
541 int regnum, num_remote_regs, offset;
542 struct remote_state *rs = get_remote_state_raw ();
543 struct remote_arch_state *rsa;
544 struct packet_reg **remote_regs;
546 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
548 /* Use the architecture to build a regnum<->pnum table, which will be
549 1:1 unless a feature set specifies otherwise. */
550 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
551 gdbarch_num_regs (gdbarch),
553 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
555 struct packet_reg *r = &rsa->regs[regnum];
557 if (register_size (gdbarch, regnum) == 0)
558 /* Do not try to fetch zero-sized (placeholder) registers. */
561 r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
566 /* Define the g/G packet format as the contents of each register
567 with a remote protocol number, in order of ascending protocol
570 remote_regs = alloca (gdbarch_num_regs (gdbarch)
571 * sizeof (struct packet_reg *));
572 for (num_remote_regs = 0, regnum = 0;
573 regnum < gdbarch_num_regs (gdbarch);
575 if (rsa->regs[regnum].pnum != -1)
576 remote_regs[num_remote_regs++] = &rsa->regs[regnum];
578 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
581 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
583 remote_regs[regnum]->in_g_packet = 1;
584 remote_regs[regnum]->offset = offset;
585 offset += register_size (gdbarch, remote_regs[regnum]->regnum);
588 /* Record the maximum possible size of the g packet - it may turn out
590 rsa->sizeof_g_packet = offset;
592 /* Default maximum number of characters in a packet body. Many
593 remote stubs have a hardwired buffer size of 400 bytes
594 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
595 as the maximum packet-size to ensure that the packet and an extra
596 NUL character can always fit in the buffer. This stops GDB
597 trashing stubs that try to squeeze an extra NUL into what is
598 already a full buffer (As of 1999-12-04 that was most stubs). */
599 rsa->remote_packet_size = 400 - 1;
601 /* This one is filled in when a ``g'' packet is received. */
602 rsa->actual_register_packet_size = 0;
604 /* Should rsa->sizeof_g_packet needs more space than the
605 default, adjust the size accordingly. Remember that each byte is
606 encoded as two characters. 32 is the overhead for the packet
607 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
608 (``$NN:G...#NN'') is a better guess, the below has been padded a
610 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
611 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
613 /* Make sure that the packet buffer is plenty big enough for
614 this architecture. */
615 if (rs->buf_size < rsa->remote_packet_size)
617 rs->buf_size = 2 * rsa->remote_packet_size;
618 rs->buf = xrealloc (rs->buf, rs->buf_size);
624 /* Return the current allowed size of a remote packet. This is
625 inferred from the current architecture, and should be used to
626 limit the length of outgoing packets. */
628 get_remote_packet_size (void)
630 struct remote_state *rs = get_remote_state ();
631 struct remote_arch_state *rsa = get_remote_arch_state ();
633 if (rs->explicit_packet_size)
634 return rs->explicit_packet_size;
636 return rsa->remote_packet_size;
639 static struct packet_reg *
640 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
642 if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch))
646 struct packet_reg *r = &rsa->regs[regnum];
648 gdb_assert (r->regnum == regnum);
653 static struct packet_reg *
654 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
658 for (i = 0; i < gdbarch_num_regs (target_gdbarch); i++)
660 struct packet_reg *r = &rsa->regs[i];
668 /* FIXME: graces/2002-08-08: These variables should eventually be
669 bound to an instance of the target object (as in gdbarch-tdep()),
670 when such a thing exists. */
672 /* This is set to the data address of the access causing the target
673 to stop for a watchpoint. */
674 static CORE_ADDR remote_watch_data_address;
676 /* This is non-zero if target stopped for a watchpoint. */
677 static int remote_stopped_by_watchpoint_p;
679 static struct target_ops remote_ops;
681 static struct target_ops extended_remote_ops;
683 static int remote_async_mask_value = 1;
685 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
686 ``forever'' still use the normal timeout mechanism. This is
687 currently used by the ASYNC code to guarentee that target reads
688 during the initial connect always time-out. Once getpkt has been
689 modified to return a timeout indication and, in turn
690 remote_wait()/wait_for_inferior() have gained a timeout parameter
692 static int wait_forever_enabled_p = 1;
694 /* Allow the user to specify what sequence to send to the remote
695 when he requests a program interruption: Although ^C is usually
696 what remote systems expect (this is the default, here), it is
697 sometimes preferable to send a break. On other systems such
698 as the Linux kernel, a break followed by g, which is Magic SysRq g
699 is required in order to interrupt the execution. */
700 const char interrupt_sequence_control_c[] = "Ctrl-C";
701 const char interrupt_sequence_break[] = "BREAK";
702 const char interrupt_sequence_break_g[] = "BREAK-g";
703 static const char *interrupt_sequence_modes[] =
705 interrupt_sequence_control_c,
706 interrupt_sequence_break,
707 interrupt_sequence_break_g,
710 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
713 show_interrupt_sequence (struct ui_file *file, int from_tty,
714 struct cmd_list_element *c,
717 if (interrupt_sequence_mode == interrupt_sequence_control_c)
718 fprintf_filtered (file,
719 _("Send the ASCII ETX character (Ctrl-c) "
720 "to the remote target to interrupt the "
721 "execution of the program.\n"));
722 else if (interrupt_sequence_mode == interrupt_sequence_break)
723 fprintf_filtered (file,
724 _("send a break signal to the remote target "
725 "to interrupt the execution of the program.\n"));
726 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
727 fprintf_filtered (file,
728 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
729 "the remote target to interrupt the execution "
730 "of Linux kernel.\n"));
732 internal_error (__FILE__, __LINE__,
733 _("Invalid value for interrupt_sequence_mode: %s."),
734 interrupt_sequence_mode);
737 /* This boolean variable specifies whether interrupt_sequence is sent
738 to the remote target when gdb connects to it.
739 This is mostly needed when you debug the Linux kernel: The Linux kernel
740 expects BREAK g which is Magic SysRq g for connecting gdb. */
741 static int interrupt_on_connect = 0;
743 /* This variable is used to implement the "set/show remotebreak" commands.
744 Since these commands are now deprecated in favor of "set/show remote
745 interrupt-sequence", it no longer has any effect on the code. */
746 static int remote_break;
749 set_remotebreak (char *args, int from_tty, struct cmd_list_element *c)
752 interrupt_sequence_mode = interrupt_sequence_break;
754 interrupt_sequence_mode = interrupt_sequence_control_c;
758 show_remotebreak (struct ui_file *file, int from_tty,
759 struct cmd_list_element *c,
764 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
765 remote_open knows that we don't have a file open when the program
767 static struct serial *remote_desc = NULL;
769 /* This variable sets the number of bits in an address that are to be
770 sent in a memory ("M" or "m") packet. Normally, after stripping
771 leading zeros, the entire address would be sent. This variable
772 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
773 initial implementation of remote.c restricted the address sent in
774 memory packets to ``host::sizeof long'' bytes - (typically 32
775 bits). Consequently, for 64 bit targets, the upper 32 bits of an
776 address was never sent. Since fixing this bug may cause a break in
777 some remote targets this variable is principly provided to
778 facilitate backward compatibility. */
780 static int remote_address_size;
782 /* Temporary to track who currently owns the terminal. See
783 remote_terminal_* for more details. */
785 static int remote_async_terminal_ours_p;
787 /* The executable file to use for "run" on the remote side. */
789 static char *remote_exec_file = "";
792 /* User configurable variables for the number of characters in a
793 memory read/write packet. MIN (rsa->remote_packet_size,
794 rsa->sizeof_g_packet) is the default. Some targets need smaller
795 values (fifo overruns, et.al.) and some users need larger values
796 (speed up transfers). The variables ``preferred_*'' (the user
797 request), ``current_*'' (what was actually set) and ``forced_*''
798 (Positive - a soft limit, negative - a hard limit). */
800 struct memory_packet_config
807 /* Compute the current size of a read/write packet. Since this makes
808 use of ``actual_register_packet_size'' the computation is dynamic. */
811 get_memory_packet_size (struct memory_packet_config *config)
813 struct remote_state *rs = get_remote_state ();
814 struct remote_arch_state *rsa = get_remote_arch_state ();
816 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
817 law?) that some hosts don't cope very well with large alloca()
818 calls. Eventually the alloca() code will be replaced by calls to
819 xmalloc() and make_cleanups() allowing this restriction to either
820 be lifted or removed. */
821 #ifndef MAX_REMOTE_PACKET_SIZE
822 #define MAX_REMOTE_PACKET_SIZE 16384
824 /* NOTE: 20 ensures we can write at least one byte. */
825 #ifndef MIN_REMOTE_PACKET_SIZE
826 #define MIN_REMOTE_PACKET_SIZE 20
831 if (config->size <= 0)
832 what_they_get = MAX_REMOTE_PACKET_SIZE;
834 what_they_get = config->size;
838 what_they_get = get_remote_packet_size ();
839 /* Limit the packet to the size specified by the user. */
841 && what_they_get > config->size)
842 what_they_get = config->size;
844 /* Limit it to the size of the targets ``g'' response unless we have
845 permission from the stub to use a larger packet size. */
846 if (rs->explicit_packet_size == 0
847 && rsa->actual_register_packet_size > 0
848 && what_they_get > rsa->actual_register_packet_size)
849 what_they_get = rsa->actual_register_packet_size;
851 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
852 what_they_get = MAX_REMOTE_PACKET_SIZE;
853 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
854 what_they_get = MIN_REMOTE_PACKET_SIZE;
856 /* Make sure there is room in the global buffer for this packet
857 (including its trailing NUL byte). */
858 if (rs->buf_size < what_they_get + 1)
860 rs->buf_size = 2 * what_they_get;
861 rs->buf = xrealloc (rs->buf, 2 * what_they_get);
864 return what_they_get;
867 /* Update the size of a read/write packet. If they user wants
868 something really big then do a sanity check. */
871 set_memory_packet_size (char *args, struct memory_packet_config *config)
873 int fixed_p = config->fixed_p;
874 long size = config->size;
877 error (_("Argument required (integer, `fixed' or `limited')."));
878 else if (strcmp (args, "hard") == 0
879 || strcmp (args, "fixed") == 0)
881 else if (strcmp (args, "soft") == 0
882 || strcmp (args, "limit") == 0)
888 size = strtoul (args, &end, 0);
890 error (_("Invalid %s (bad syntax)."), config->name);
892 /* Instead of explicitly capping the size of a packet to
893 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
894 instead allowed to set the size to something arbitrarily
896 if (size > MAX_REMOTE_PACKET_SIZE)
897 error (_("Invalid %s (too large)."), config->name);
901 if (fixed_p && !config->fixed_p)
903 if (! query (_("The target may not be able to correctly handle a %s\n"
904 "of %ld bytes. Change the packet size? "),
906 error (_("Packet size not changed."));
908 /* Update the config. */
909 config->fixed_p = fixed_p;
914 show_memory_packet_size (struct memory_packet_config *config)
916 printf_filtered (_("The %s is %ld. "), config->name, config->size);
918 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
919 get_memory_packet_size (config));
921 printf_filtered (_("Packets are limited to %ld bytes.\n"),
922 get_memory_packet_size (config));
925 static struct memory_packet_config memory_write_packet_config =
927 "memory-write-packet-size",
931 set_memory_write_packet_size (char *args, int from_tty)
933 set_memory_packet_size (args, &memory_write_packet_config);
937 show_memory_write_packet_size (char *args, int from_tty)
939 show_memory_packet_size (&memory_write_packet_config);
943 get_memory_write_packet_size (void)
945 return get_memory_packet_size (&memory_write_packet_config);
948 static struct memory_packet_config memory_read_packet_config =
950 "memory-read-packet-size",
954 set_memory_read_packet_size (char *args, int from_tty)
956 set_memory_packet_size (args, &memory_read_packet_config);
960 show_memory_read_packet_size (char *args, int from_tty)
962 show_memory_packet_size (&memory_read_packet_config);
966 get_memory_read_packet_size (void)
968 long size = get_memory_packet_size (&memory_read_packet_config);
970 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
971 extra buffer size argument before the memory read size can be
972 increased beyond this. */
973 if (size > get_remote_packet_size ())
974 size = get_remote_packet_size ();
979 /* Generic configuration support for packets the stub optionally
980 supports. Allows the user to specify the use of the packet as well
981 as allowing GDB to auto-detect support in the remote stub. */
985 PACKET_SUPPORT_UNKNOWN = 0,
994 enum auto_boolean detect;
995 enum packet_support support;
998 /* Analyze a packet's return value and update the packet config
1009 update_packet_config (struct packet_config *config)
1011 switch (config->detect)
1013 case AUTO_BOOLEAN_TRUE:
1014 config->support = PACKET_ENABLE;
1016 case AUTO_BOOLEAN_FALSE:
1017 config->support = PACKET_DISABLE;
1019 case AUTO_BOOLEAN_AUTO:
1020 config->support = PACKET_SUPPORT_UNKNOWN;
1026 show_packet_config_cmd (struct packet_config *config)
1028 char *support = "internal-error";
1030 switch (config->support)
1033 support = "enabled";
1035 case PACKET_DISABLE:
1036 support = "disabled";
1038 case PACKET_SUPPORT_UNKNOWN:
1039 support = "unknown";
1042 switch (config->detect)
1044 case AUTO_BOOLEAN_AUTO:
1045 printf_filtered (_("Support for the `%s' packet "
1046 "is auto-detected, currently %s.\n"),
1047 config->name, support);
1049 case AUTO_BOOLEAN_TRUE:
1050 case AUTO_BOOLEAN_FALSE:
1051 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1052 config->name, support);
1058 add_packet_config_cmd (struct packet_config *config, const char *name,
1059 const char *title, int legacy)
1065 config->name = name;
1066 config->title = title;
1067 config->detect = AUTO_BOOLEAN_AUTO;
1068 config->support = PACKET_SUPPORT_UNKNOWN;
1069 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1071 show_doc = xstrprintf ("Show current use of remote "
1072 "protocol `%s' (%s) packet",
1074 /* set/show TITLE-packet {auto,on,off} */
1075 cmd_name = xstrprintf ("%s-packet", title);
1076 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1077 &config->detect, set_doc,
1078 show_doc, NULL, /* help_doc */
1079 set_remote_protocol_packet_cmd,
1080 show_remote_protocol_packet_cmd,
1081 &remote_set_cmdlist, &remote_show_cmdlist);
1082 /* The command code copies the documentation strings. */
1085 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1090 legacy_name = xstrprintf ("%s-packet", name);
1091 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1092 &remote_set_cmdlist);
1093 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1094 &remote_show_cmdlist);
1098 static enum packet_result
1099 packet_check_result (const char *buf)
1103 /* The stub recognized the packet request. Check that the
1104 operation succeeded. */
1106 && isxdigit (buf[1]) && isxdigit (buf[2])
1108 /* "Enn" - definitly an error. */
1109 return PACKET_ERROR;
1111 /* Always treat "E." as an error. This will be used for
1112 more verbose error messages, such as E.memtypes. */
1113 if (buf[0] == 'E' && buf[1] == '.')
1114 return PACKET_ERROR;
1116 /* The packet may or may not be OK. Just assume it is. */
1120 /* The stub does not support the packet. */
1121 return PACKET_UNKNOWN;
1124 static enum packet_result
1125 packet_ok (const char *buf, struct packet_config *config)
1127 enum packet_result result;
1129 result = packet_check_result (buf);
1134 /* The stub recognized the packet request. */
1135 switch (config->support)
1137 case PACKET_SUPPORT_UNKNOWN:
1139 fprintf_unfiltered (gdb_stdlog,
1140 "Packet %s (%s) is supported\n",
1141 config->name, config->title);
1142 config->support = PACKET_ENABLE;
1144 case PACKET_DISABLE:
1145 internal_error (__FILE__, __LINE__,
1146 _("packet_ok: attempt to use a disabled packet"));
1152 case PACKET_UNKNOWN:
1153 /* The stub does not support the packet. */
1154 switch (config->support)
1157 if (config->detect == AUTO_BOOLEAN_AUTO)
1158 /* If the stub previously indicated that the packet was
1159 supported then there is a protocol error.. */
1160 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1161 config->name, config->title);
1163 /* The user set it wrong. */
1164 error (_("Enabled packet %s (%s) not recognized by stub"),
1165 config->name, config->title);
1167 case PACKET_SUPPORT_UNKNOWN:
1169 fprintf_unfiltered (gdb_stdlog,
1170 "Packet %s (%s) is NOT supported\n",
1171 config->name, config->title);
1172 config->support = PACKET_DISABLE;
1174 case PACKET_DISABLE:
1196 PACKET_vFile_pwrite,
1198 PACKET_vFile_unlink,
1200 PACKET_qXfer_features,
1201 PACKET_qXfer_libraries,
1202 PACKET_qXfer_memory_map,
1203 PACKET_qXfer_spu_read,
1204 PACKET_qXfer_spu_write,
1205 PACKET_qXfer_osdata,
1206 PACKET_qXfer_threads,
1207 PACKET_qXfer_statictrace_read,
1211 PACKET_QPassSignals,
1212 PACKET_qSearch_memory,
1215 PACKET_QStartNoAckMode,
1217 PACKET_qXfer_siginfo_read,
1218 PACKET_qXfer_siginfo_write,
1220 PACKET_ConditionalTracepoints,
1221 PACKET_FastTracepoints,
1222 PACKET_StaticTracepoints,
1225 PACKET_TracepointSource,
1230 static struct packet_config remote_protocol_packets[PACKET_MAX];
1233 set_remote_protocol_packet_cmd (char *args, int from_tty,
1234 struct cmd_list_element *c)
1236 struct packet_config *packet;
1238 for (packet = remote_protocol_packets;
1239 packet < &remote_protocol_packets[PACKET_MAX];
1242 if (&packet->detect == c->var)
1244 update_packet_config (packet);
1248 internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1253 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
1254 struct cmd_list_element *c,
1257 struct packet_config *packet;
1259 for (packet = remote_protocol_packets;
1260 packet < &remote_protocol_packets[PACKET_MAX];
1263 if (&packet->detect == c->var)
1265 show_packet_config_cmd (packet);
1269 internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1273 /* Should we try one of the 'Z' requests? */
1277 Z_PACKET_SOFTWARE_BP,
1278 Z_PACKET_HARDWARE_BP,
1285 /* For compatibility with older distributions. Provide a ``set remote
1286 Z-packet ...'' command that updates all the Z packet types. */
1288 static enum auto_boolean remote_Z_packet_detect;
1291 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
1292 struct cmd_list_element *c)
1296 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1298 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
1299 update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
1304 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
1305 struct cmd_list_element *c,
1310 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1312 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1316 /* Should we try the 'ThreadInfo' query packet?
1318 This variable (NOT available to the user: auto-detect only!)
1319 determines whether GDB will use the new, simpler "ThreadInfo"
1320 query or the older, more complex syntax for thread queries.
1321 This is an auto-detect variable (set to true at each connect,
1322 and set to false when the target fails to recognize it). */
1324 static int use_threadinfo_query;
1325 static int use_threadextra_query;
1327 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1328 static struct async_signal_handler *sigint_remote_twice_token;
1329 static struct async_signal_handler *sigint_remote_token;
1332 /* Asynchronous signal handle registered as event loop source for
1333 when we have pending events ready to be passed to the core. */
1335 static struct async_event_handler *remote_async_inferior_event_token;
1337 /* Asynchronous signal handle registered as event loop source for when
1338 the remote sent us a %Stop notification. The registered callback
1339 will do a vStopped sequence to pull the rest of the events out of
1340 the remote side into our event queue. */
1342 static struct async_event_handler *remote_async_get_pending_events_token;
1345 static ptid_t magic_null_ptid;
1346 static ptid_t not_sent_ptid;
1347 static ptid_t any_thread_ptid;
1349 /* These are the threads which we last sent to the remote system. The
1350 TID member will be -1 for all or -2 for not sent yet. */
1352 static ptid_t general_thread;
1353 static ptid_t continue_thread;
1355 /* Find out if the stub attached to PID (and hence GDB should offer to
1356 detach instead of killing it when bailing out). */
1359 remote_query_attached (int pid)
1361 struct remote_state *rs = get_remote_state ();
1363 if (remote_protocol_packets[PACKET_qAttached].support == PACKET_DISABLE)
1366 if (remote_multi_process_p (rs))
1367 sprintf (rs->buf, "qAttached:%x", pid);
1369 sprintf (rs->buf, "qAttached");
1372 getpkt (&rs->buf, &rs->buf_size, 0);
1374 switch (packet_ok (rs->buf,
1375 &remote_protocol_packets[PACKET_qAttached]))
1378 if (strcmp (rs->buf, "1") == 0)
1382 warning (_("Remote failure reply: %s"), rs->buf);
1384 case PACKET_UNKNOWN:
1391 /* Add PID to GDB's inferior table. Since we can be connected to a
1392 remote system before before knowing about any inferior, mark the
1393 target with execution when we find the first inferior. If ATTACHED
1394 is 1, then we had just attached to this inferior. If it is 0, then
1395 we just created this inferior. If it is -1, then try querying the
1396 remote stub to find out if it had attached to the inferior or
1399 static struct inferior *
1400 remote_add_inferior (int pid, int attached)
1402 struct inferior *inf;
1404 /* Check whether this process we're learning about is to be
1405 considered attached, or if is to be considered to have been
1406 spawned by the stub. */
1408 attached = remote_query_attached (pid);
1410 if (gdbarch_has_global_solist (target_gdbarch))
1412 /* If the target shares code across all inferiors, then every
1413 attach adds a new inferior. */
1414 inf = add_inferior (pid);
1416 /* ... and every inferior is bound to the same program space.
1417 However, each inferior may still have its own address
1419 inf->aspace = maybe_new_address_space ();
1420 inf->pspace = current_program_space;
1424 /* In the traditional debugging scenario, there's a 1-1 match
1425 between program/address spaces. We simply bind the inferior
1426 to the program space's address space. */
1427 inf = current_inferior ();
1428 inferior_appeared (inf, pid);
1431 inf->attach_flag = attached;
1436 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1437 according to RUNNING. */
1440 remote_add_thread (ptid_t ptid, int running)
1444 set_executing (ptid, running);
1445 set_running (ptid, running);
1448 /* Come here when we learn about a thread id from the remote target.
1449 It may be the first time we hear about such thread, so take the
1450 opportunity to add it to GDB's thread list. In case this is the
1451 first time we're noticing its corresponding inferior, add it to
1452 GDB's inferior list as well. */
1455 remote_notice_new_inferior (ptid_t currthread, int running)
1457 /* If this is a new thread, add it to GDB's thread list.
1458 If we leave it up to WFI to do this, bad things will happen. */
1460 if (in_thread_list (currthread) && is_exited (currthread))
1462 /* We're seeing an event on a thread id we knew had exited.
1463 This has to be a new thread reusing the old id. Add it. */
1464 remote_add_thread (currthread, running);
1468 if (!in_thread_list (currthread))
1470 struct inferior *inf = NULL;
1471 int pid = ptid_get_pid (currthread);
1473 if (ptid_is_pid (inferior_ptid)
1474 && pid == ptid_get_pid (inferior_ptid))
1476 /* inferior_ptid has no thread member yet. This can happen
1477 with the vAttach -> remote_wait,"TAAthread:" path if the
1478 stub doesn't support qC. This is the first stop reported
1479 after an attach, so this is the main thread. Update the
1480 ptid in the thread list. */
1481 if (in_thread_list (pid_to_ptid (pid)))
1482 thread_change_ptid (inferior_ptid, currthread);
1485 remote_add_thread (currthread, running);
1486 inferior_ptid = currthread;
1491 if (ptid_equal (magic_null_ptid, inferior_ptid))
1493 /* inferior_ptid is not set yet. This can happen with the
1494 vRun -> remote_wait,"TAAthread:" path if the stub
1495 doesn't support qC. This is the first stop reported
1496 after an attach, so this is the main thread. Update the
1497 ptid in the thread list. */
1498 thread_change_ptid (inferior_ptid, currthread);
1502 /* When connecting to a target remote, or to a target
1503 extended-remote which already was debugging an inferior, we
1504 may not know about it yet. Add it before adding its child
1505 thread, so notifications are emitted in a sensible order. */
1506 if (!in_inferior_list (ptid_get_pid (currthread)))
1507 inf = remote_add_inferior (ptid_get_pid (currthread), -1);
1509 /* This is really a new thread. Add it. */
1510 remote_add_thread (currthread, running);
1512 /* If we found a new inferior, let the common code do whatever
1513 it needs to with it (e.g., read shared libraries, insert
1516 notice_new_inferior (currthread, running, 0);
1520 /* Return the private thread data, creating it if necessary. */
1522 struct private_thread_info *
1523 demand_private_info (ptid_t ptid)
1525 struct thread_info *info = find_thread_ptid (ptid);
1531 info->private = xmalloc (sizeof (*(info->private)));
1532 info->private_dtor = free_private_thread_info;
1533 info->private->core = -1;
1534 info->private->extra = 0;
1537 return info->private;
1540 /* Call this function as a result of
1541 1) A halt indication (T packet) containing a thread id
1542 2) A direct query of currthread
1543 3) Successful execution of set thread */
1546 record_currthread (ptid_t currthread)
1548 general_thread = currthread;
1551 static char *last_pass_packet;
1553 /* If 'QPassSignals' is supported, tell the remote stub what signals
1554 it can simply pass through to the inferior without reporting. */
1557 remote_pass_signals (void)
1559 if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
1561 char *pass_packet, *p;
1562 int numsigs = (int) TARGET_SIGNAL_LAST;
1565 gdb_assert (numsigs < 256);
1566 for (i = 0; i < numsigs; i++)
1568 if (signal_stop_state (i) == 0
1569 && signal_print_state (i) == 0
1570 && signal_pass_state (i) == 1)
1573 pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
1574 strcpy (pass_packet, "QPassSignals:");
1575 p = pass_packet + strlen (pass_packet);
1576 for (i = 0; i < numsigs; i++)
1578 if (signal_stop_state (i) == 0
1579 && signal_print_state (i) == 0
1580 && signal_pass_state (i) == 1)
1583 *p++ = tohex (i >> 4);
1584 *p++ = tohex (i & 15);
1593 if (!last_pass_packet || strcmp (last_pass_packet, pass_packet))
1595 struct remote_state *rs = get_remote_state ();
1596 char *buf = rs->buf;
1598 putpkt (pass_packet);
1599 getpkt (&rs->buf, &rs->buf_size, 0);
1600 packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
1601 if (last_pass_packet)
1602 xfree (last_pass_packet);
1603 last_pass_packet = pass_packet;
1606 xfree (pass_packet);
1611 remote_notice_signals (ptid_t ptid)
1613 /* Update the remote on signals to silently pass, if they've
1615 remote_pass_signals ();
1618 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
1619 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1620 thread. If GEN is set, set the general thread, if not, then set
1621 the step/continue thread. */
1623 set_thread (struct ptid ptid, int gen)
1625 struct remote_state *rs = get_remote_state ();
1626 ptid_t state = gen ? general_thread : continue_thread;
1627 char *buf = rs->buf;
1628 char *endbuf = rs->buf + get_remote_packet_size ();
1630 if (ptid_equal (state, ptid))
1634 *buf++ = gen ? 'g' : 'c';
1635 if (ptid_equal (ptid, magic_null_ptid))
1636 xsnprintf (buf, endbuf - buf, "0");
1637 else if (ptid_equal (ptid, any_thread_ptid))
1638 xsnprintf (buf, endbuf - buf, "0");
1639 else if (ptid_equal (ptid, minus_one_ptid))
1640 xsnprintf (buf, endbuf - buf, "-1");
1642 write_ptid (buf, endbuf, ptid);
1644 getpkt (&rs->buf, &rs->buf_size, 0);
1646 general_thread = ptid;
1648 continue_thread = ptid;
1652 set_general_thread (struct ptid ptid)
1654 set_thread (ptid, 1);
1658 set_continue_thread (struct ptid ptid)
1660 set_thread (ptid, 0);
1663 /* Change the remote current process. Which thread within the process
1664 ends up selected isn't important, as long as it is the same process
1665 as what INFERIOR_PTID points to.
1667 This comes from that fact that there is no explicit notion of
1668 "selected process" in the protocol. The selected process for
1669 general operations is the process the selected general thread
1673 set_general_process (void)
1675 struct remote_state *rs = get_remote_state ();
1677 /* If the remote can't handle multiple processes, don't bother. */
1678 if (!remote_multi_process_p (rs))
1681 /* We only need to change the remote current thread if it's pointing
1682 at some other process. */
1683 if (ptid_get_pid (general_thread) != ptid_get_pid (inferior_ptid))
1684 set_general_thread (inferior_ptid);
1688 /* Return nonzero if the thread PTID is still alive on the remote
1692 remote_thread_alive (struct target_ops *ops, ptid_t ptid)
1694 struct remote_state *rs = get_remote_state ();
1697 if (ptid_equal (ptid, magic_null_ptid))
1698 /* The main thread is always alive. */
1701 if (ptid_get_pid (ptid) != 0 && ptid_get_tid (ptid) == 0)
1702 /* The main thread is always alive. This can happen after a
1703 vAttach, if the remote side doesn't support
1708 endp = rs->buf + get_remote_packet_size ();
1711 write_ptid (p, endp, ptid);
1714 getpkt (&rs->buf, &rs->buf_size, 0);
1715 return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
1718 /* About these extended threadlist and threadinfo packets. They are
1719 variable length packets but, the fields within them are often fixed
1720 length. They are redundent enough to send over UDP as is the
1721 remote protocol in general. There is a matching unit test module
1724 #define OPAQUETHREADBYTES 8
1726 /* a 64 bit opaque identifier */
1727 typedef unsigned char threadref[OPAQUETHREADBYTES];
1729 /* WARNING: This threadref data structure comes from the remote O.S.,
1730 libstub protocol encoding, and remote.c. It is not particularly
1733 /* Right now, the internal structure is int. We want it to be bigger.
1734 Plan to fix this. */
1736 typedef int gdb_threadref; /* Internal GDB thread reference. */
1738 /* gdb_ext_thread_info is an internal GDB data structure which is
1739 equivalent to the reply of the remote threadinfo packet. */
1741 struct gdb_ext_thread_info
1743 threadref threadid; /* External form of thread reference. */
1744 int active; /* Has state interesting to GDB?
1746 char display[256]; /* Brief state display, name,
1747 blocked/suspended. */
1748 char shortname[32]; /* To be used to name threads. */
1749 char more_display[256]; /* Long info, statistics, queue depth,
1753 /* The volume of remote transfers can be limited by submitting
1754 a mask containing bits specifying the desired information.
1755 Use a union of these values as the 'selection' parameter to
1756 get_thread_info. FIXME: Make these TAG names more thread specific. */
1758 #define TAG_THREADID 1
1759 #define TAG_EXISTS 2
1760 #define TAG_DISPLAY 4
1761 #define TAG_THREADNAME 8
1762 #define TAG_MOREDISPLAY 16
1764 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1766 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1768 static char *unpack_nibble (char *buf, int *val);
1770 static char *pack_nibble (char *buf, int nibble);
1772 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1774 static char *unpack_byte (char *buf, int *value);
1776 static char *pack_int (char *buf, int value);
1778 static char *unpack_int (char *buf, int *value);
1780 static char *unpack_string (char *src, char *dest, int length);
1782 static char *pack_threadid (char *pkt, threadref *id);
1784 static char *unpack_threadid (char *inbuf, threadref *id);
1786 void int_to_threadref (threadref *id, int value);
1788 static int threadref_to_int (threadref *ref);
1790 static void copy_threadref (threadref *dest, threadref *src);
1792 static int threadmatch (threadref *dest, threadref *src);
1794 static char *pack_threadinfo_request (char *pkt, int mode,
1797 static int remote_unpack_thread_info_response (char *pkt,
1798 threadref *expectedref,
1799 struct gdb_ext_thread_info
1803 static int remote_get_threadinfo (threadref *threadid,
1804 int fieldset, /*TAG mask */
1805 struct gdb_ext_thread_info *info);
1807 static char *pack_threadlist_request (char *pkt, int startflag,
1809 threadref *nextthread);
1811 static int parse_threadlist_response (char *pkt,
1813 threadref *original_echo,
1814 threadref *resultlist,
1817 static int remote_get_threadlist (int startflag,
1818 threadref *nextthread,
1822 threadref *threadlist);
1824 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1826 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1827 void *context, int looplimit);
1829 static int remote_newthread_step (threadref *ref, void *context);
1832 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
1833 buffer we're allowed to write to. Returns
1834 BUF+CHARACTERS_WRITTEN. */
1837 write_ptid (char *buf, const char *endbuf, ptid_t ptid)
1840 struct remote_state *rs = get_remote_state ();
1842 if (remote_multi_process_p (rs))
1844 pid = ptid_get_pid (ptid);
1846 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
1848 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
1850 tid = ptid_get_tid (ptid);
1852 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
1854 buf += xsnprintf (buf, endbuf - buf, "%x", tid);
1859 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
1860 passed the last parsed char. Returns null_ptid on error. */
1863 read_ptid (char *buf, char **obuf)
1867 ULONGEST pid = 0, tid = 0;
1871 /* Multi-process ptid. */
1872 pp = unpack_varlen_hex (p + 1, &pid);
1874 error (_("invalid remote ptid: %s\n"), p);
1877 pp = unpack_varlen_hex (p + 1, &tid);
1880 return ptid_build (pid, 0, tid);
1883 /* No multi-process. Just a tid. */
1884 pp = unpack_varlen_hex (p, &tid);
1886 /* Since the stub is not sending a process id, then default to
1887 what's in inferior_ptid, unless it's null at this point. If so,
1888 then since there's no way to know the pid of the reported
1889 threads, use the magic number. */
1890 if (ptid_equal (inferior_ptid, null_ptid))
1891 pid = ptid_get_pid (magic_null_ptid);
1893 pid = ptid_get_pid (inferior_ptid);
1897 return ptid_build (pid, 0, tid);
1900 /* Encode 64 bits in 16 chars of hex. */
1902 static const char hexchars[] = "0123456789abcdef";
1905 ishex (int ch, int *val)
1907 if ((ch >= 'a') && (ch <= 'f'))
1909 *val = ch - 'a' + 10;
1912 if ((ch >= 'A') && (ch <= 'F'))
1914 *val = ch - 'A' + 10;
1917 if ((ch >= '0') && (ch <= '9'))
1928 if (ch >= 'a' && ch <= 'f')
1929 return ch - 'a' + 10;
1930 if (ch >= '0' && ch <= '9')
1932 if (ch >= 'A' && ch <= 'F')
1933 return ch - 'A' + 10;
1938 stub_unpack_int (char *buff, int fieldlength)
1945 nibble = stubhex (*buff++);
1949 retval = retval << 4;
1955 unpack_varlen_hex (char *buff, /* packet to parse */
1959 ULONGEST retval = 0;
1961 while (ishex (*buff, &nibble))
1964 retval = retval << 4;
1965 retval |= nibble & 0x0f;
1972 unpack_nibble (char *buf, int *val)
1974 *val = fromhex (*buf++);
1979 pack_nibble (char *buf, int nibble)
1981 *buf++ = hexchars[(nibble & 0x0f)];
1986 pack_hex_byte (char *pkt, int byte)
1988 *pkt++ = hexchars[(byte >> 4) & 0xf];
1989 *pkt++ = hexchars[(byte & 0xf)];
1994 unpack_byte (char *buf, int *value)
1996 *value = stub_unpack_int (buf, 2);
2001 pack_int (char *buf, int value)
2003 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
2004 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
2005 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
2006 buf = pack_hex_byte (buf, (value & 0xff));
2011 unpack_int (char *buf, int *value)
2013 *value = stub_unpack_int (buf, 8);
2017 #if 0 /* Currently unused, uncomment when needed. */
2018 static char *pack_string (char *pkt, char *string);
2021 pack_string (char *pkt, char *string)
2026 len = strlen (string);
2028 len = 200; /* Bigger than most GDB packets, junk??? */
2029 pkt = pack_hex_byte (pkt, len);
2033 if ((ch == '\0') || (ch == '#'))
2034 ch = '*'; /* Protect encapsulation. */
2039 #endif /* 0 (unused) */
2042 unpack_string (char *src, char *dest, int length)
2051 pack_threadid (char *pkt, threadref *id)
2054 unsigned char *altid;
2056 altid = (unsigned char *) id;
2057 limit = pkt + BUF_THREAD_ID_SIZE;
2059 pkt = pack_hex_byte (pkt, *altid++);
2065 unpack_threadid (char *inbuf, threadref *id)
2068 char *limit = inbuf + BUF_THREAD_ID_SIZE;
2071 altref = (char *) id;
2073 while (inbuf < limit)
2075 x = stubhex (*inbuf++);
2076 y = stubhex (*inbuf++);
2077 *altref++ = (x << 4) | y;
2082 /* Externally, threadrefs are 64 bits but internally, they are still
2083 ints. This is due to a mismatch of specifications. We would like
2084 to use 64bit thread references internally. This is an adapter
2088 int_to_threadref (threadref *id, int value)
2090 unsigned char *scan;
2092 scan = (unsigned char *) id;
2098 *scan++ = (value >> 24) & 0xff;
2099 *scan++ = (value >> 16) & 0xff;
2100 *scan++ = (value >> 8) & 0xff;
2101 *scan++ = (value & 0xff);
2105 threadref_to_int (threadref *ref)
2108 unsigned char *scan;
2114 value = (value << 8) | ((*scan++) & 0xff);
2119 copy_threadref (threadref *dest, threadref *src)
2122 unsigned char *csrc, *cdest;
2124 csrc = (unsigned char *) src;
2125 cdest = (unsigned char *) dest;
2132 threadmatch (threadref *dest, threadref *src)
2134 /* Things are broken right now, so just assume we got a match. */
2136 unsigned char *srcp, *destp;
2138 srcp = (char *) src;
2139 destp = (char *) dest;
2143 result &= (*srcp++ == *destp++) ? 1 : 0;
2150 threadid:1, # always request threadid
2157 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2160 pack_threadinfo_request (char *pkt, int mode, threadref *id)
2162 *pkt++ = 'q'; /* Info Query */
2163 *pkt++ = 'P'; /* process or thread info */
2164 pkt = pack_int (pkt, mode); /* mode */
2165 pkt = pack_threadid (pkt, id); /* threadid */
2166 *pkt = '\0'; /* terminate */
2170 /* These values tag the fields in a thread info response packet. */
2171 /* Tagging the fields allows us to request specific fields and to
2172 add more fields as time goes by. */
2174 #define TAG_THREADID 1 /* Echo the thread identifier. */
2175 #define TAG_EXISTS 2 /* Is this process defined enough to
2176 fetch registers and its stack? */
2177 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2178 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2179 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2183 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
2184 struct gdb_ext_thread_info *info)
2186 struct remote_state *rs = get_remote_state ();
2190 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
2193 /* info->threadid = 0; FIXME: implement zero_threadref. */
2195 info->display[0] = '\0';
2196 info->shortname[0] = '\0';
2197 info->more_display[0] = '\0';
2199 /* Assume the characters indicating the packet type have been
2201 pkt = unpack_int (pkt, &mask); /* arg mask */
2202 pkt = unpack_threadid (pkt, &ref);
2205 warning (_("Incomplete response to threadinfo request."));
2206 if (!threadmatch (&ref, expectedref))
2207 { /* This is an answer to a different request. */
2208 warning (_("ERROR RMT Thread info mismatch."));
2211 copy_threadref (&info->threadid, &ref);
2213 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2215 /* Packets are terminated with nulls. */
2216 while ((pkt < limit) && mask && *pkt)
2218 pkt = unpack_int (pkt, &tag); /* tag */
2219 pkt = unpack_byte (pkt, &length); /* length */
2220 if (!(tag & mask)) /* Tags out of synch with mask. */
2222 warning (_("ERROR RMT: threadinfo tag mismatch."));
2226 if (tag == TAG_THREADID)
2230 warning (_("ERROR RMT: length of threadid is not 16."));
2234 pkt = unpack_threadid (pkt, &ref);
2235 mask = mask & ~TAG_THREADID;
2238 if (tag == TAG_EXISTS)
2240 info->active = stub_unpack_int (pkt, length);
2242 mask = mask & ~(TAG_EXISTS);
2245 warning (_("ERROR RMT: 'exists' length too long."));
2251 if (tag == TAG_THREADNAME)
2253 pkt = unpack_string (pkt, &info->shortname[0], length);
2254 mask = mask & ~TAG_THREADNAME;
2257 if (tag == TAG_DISPLAY)
2259 pkt = unpack_string (pkt, &info->display[0], length);
2260 mask = mask & ~TAG_DISPLAY;
2263 if (tag == TAG_MOREDISPLAY)
2265 pkt = unpack_string (pkt, &info->more_display[0], length);
2266 mask = mask & ~TAG_MOREDISPLAY;
2269 warning (_("ERROR RMT: unknown thread info tag."));
2270 break; /* Not a tag we know about. */
2276 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
2277 struct gdb_ext_thread_info *info)
2279 struct remote_state *rs = get_remote_state ();
2282 pack_threadinfo_request (rs->buf, fieldset, threadid);
2284 getpkt (&rs->buf, &rs->buf_size, 0);
2286 if (rs->buf[0] == '\0')
2289 result = remote_unpack_thread_info_response (rs->buf + 2,
2294 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2297 pack_threadlist_request (char *pkt, int startflag, int threadcount,
2298 threadref *nextthread)
2300 *pkt++ = 'q'; /* info query packet */
2301 *pkt++ = 'L'; /* Process LIST or threadLIST request */
2302 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
2303 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
2304 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
2309 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2312 parse_threadlist_response (char *pkt, int result_limit,
2313 threadref *original_echo, threadref *resultlist,
2316 struct remote_state *rs = get_remote_state ();
2318 int count, resultcount, done;
2321 /* Assume the 'q' and 'M chars have been stripped. */
2322 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
2323 /* done parse past here */
2324 pkt = unpack_byte (pkt, &count); /* count field */
2325 pkt = unpack_nibble (pkt, &done);
2326 /* The first threadid is the argument threadid. */
2327 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
2328 while ((count-- > 0) && (pkt < limit))
2330 pkt = unpack_threadid (pkt, resultlist++);
2331 if (resultcount++ >= result_limit)
2340 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
2341 int *done, int *result_count, threadref *threadlist)
2343 struct remote_state *rs = get_remote_state ();
2344 static threadref echo_nextthread;
2347 /* Trancate result limit to be smaller than the packet size. */
2348 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
2349 >= get_remote_packet_size ())
2350 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
2352 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
2354 getpkt (&rs->buf, &rs->buf_size, 0);
2356 if (*rs->buf == '\0')
2360 parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
2363 if (!threadmatch (&echo_nextthread, nextthread))
2365 /* FIXME: This is a good reason to drop the packet. */
2366 /* Possably, there is a duplicate response. */
2368 retransmit immediatly - race conditions
2369 retransmit after timeout - yes
2371 wait for packet, then exit
2373 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2374 return 0; /* I choose simply exiting. */
2376 if (*result_count <= 0)
2380 warning (_("RMT ERROR : failed to get remote thread list."));
2383 return result; /* break; */
2385 if (*result_count > result_limit)
2388 warning (_("RMT ERROR: threadlist response longer than requested."));
2394 /* This is the interface between remote and threads, remotes upper
2397 /* remote_find_new_threads retrieves the thread list and for each
2398 thread in the list, looks up the thread in GDB's internal list,
2399 adding the thread if it does not already exist. This involves
2400 getting partial thread lists from the remote target so, polling the
2401 quit_flag is required. */
2404 /* About this many threadisds fit in a packet. */
2406 #define MAXTHREADLISTRESULTS 32
2409 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
2412 int done, i, result_count;
2416 static threadref nextthread;
2417 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
2422 if (loopcount++ > looplimit)
2425 warning (_("Remote fetch threadlist -infinite loop-."));
2428 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
2429 &done, &result_count, resultthreadlist))
2434 /* Clear for later iterations. */
2436 /* Setup to resume next batch of thread references, set nextthread. */
2437 if (result_count >= 1)
2438 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
2440 while (result_count--)
2441 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
2448 remote_newthread_step (threadref *ref, void *context)
2450 int pid = ptid_get_pid (inferior_ptid);
2451 ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref));
2453 if (!in_thread_list (ptid))
2455 return 1; /* continue iterator */
2458 #define CRAZY_MAX_THREADS 1000
2461 remote_current_thread (ptid_t oldpid)
2463 struct remote_state *rs = get_remote_state ();
2466 getpkt (&rs->buf, &rs->buf_size, 0);
2467 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
2468 return read_ptid (&rs->buf[2], NULL);
2473 /* Find new threads for info threads command.
2474 * Original version, using John Metzler's thread protocol.
2478 remote_find_new_threads (void)
2480 remote_threadlist_iterator (remote_newthread_step, 0,
2484 #if defined(HAVE_LIBEXPAT)
2486 typedef struct thread_item
2492 DEF_VEC_O(thread_item_t);
2494 struct threads_parsing_context
2496 VEC (thread_item_t) *items;
2500 start_thread (struct gdb_xml_parser *parser,
2501 const struct gdb_xml_element *element,
2502 void *user_data, VEC(gdb_xml_value_s) *attributes)
2504 struct threads_parsing_context *data = user_data;
2506 struct thread_item item;
2509 id = VEC_index (gdb_xml_value_s, attributes, 0)->value;
2510 item.ptid = read_ptid (id, NULL);
2512 if (VEC_length (gdb_xml_value_s, attributes) > 1)
2513 item.core = *(ULONGEST *) VEC_index (gdb_xml_value_s,
2514 attributes, 1)->value;
2520 VEC_safe_push (thread_item_t, data->items, &item);
2524 end_thread (struct gdb_xml_parser *parser,
2525 const struct gdb_xml_element *element,
2526 void *user_data, const char *body_text)
2528 struct threads_parsing_context *data = user_data;
2530 if (body_text && *body_text)
2531 VEC_last (thread_item_t, data->items)->extra = xstrdup (body_text);
2534 const struct gdb_xml_attribute thread_attributes[] = {
2535 { "id", GDB_XML_AF_NONE, NULL, NULL },
2536 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2537 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2540 const struct gdb_xml_element thread_children[] = {
2541 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2544 const struct gdb_xml_element threads_children[] = {
2545 { "thread", thread_attributes, thread_children,
2546 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
2547 start_thread, end_thread },
2548 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2551 const struct gdb_xml_element threads_elements[] = {
2552 { "threads", NULL, threads_children,
2553 GDB_XML_EF_NONE, NULL, NULL },
2554 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2557 /* Discard the contents of the constructed thread info context. */
2560 clear_threads_parsing_context (void *p)
2562 struct threads_parsing_context *context = p;
2564 struct thread_item *item;
2566 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
2567 xfree (item->extra);
2569 VEC_free (thread_item_t, context->items);
2575 * Find all threads for info threads command.
2576 * Uses new thread protocol contributed by Cisco.
2577 * Falls back and attempts to use the older method (above)
2578 * if the target doesn't respond to the new method.
2582 remote_threads_info (struct target_ops *ops)
2584 struct remote_state *rs = get_remote_state ();
2588 if (remote_desc == 0) /* paranoia */
2589 error (_("Command can only be used when connected to the remote target."));
2591 #if defined(HAVE_LIBEXPAT)
2592 if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
2594 char *xml = target_read_stralloc (¤t_target,
2595 TARGET_OBJECT_THREADS, NULL);
2597 struct cleanup *back_to = make_cleanup (xfree, xml);
2601 struct threads_parsing_context context;
2603 context.items = NULL;
2604 make_cleanup (clear_threads_parsing_context, &context);
2606 if (gdb_xml_parse_quick (_("threads"), "threads.dtd",
2607 threads_elements, xml, &context) == 0)
2610 struct thread_item *item;
2613 VEC_iterate (thread_item_t, context.items, i, item);
2616 if (!ptid_equal (item->ptid, null_ptid))
2618 struct private_thread_info *info;
2619 /* In non-stop mode, we assume new found threads
2620 are running until proven otherwise with a
2621 stop reply. In all-stop, we can only get
2622 here if all threads are stopped. */
2623 int running = non_stop ? 1 : 0;
2625 remote_notice_new_inferior (item->ptid, running);
2627 info = demand_private_info (item->ptid);
2628 info->core = item->core;
2629 info->extra = item->extra;
2636 do_cleanups (back_to);
2641 if (use_threadinfo_query)
2643 putpkt ("qfThreadInfo");
2644 getpkt (&rs->buf, &rs->buf_size, 0);
2646 if (bufp[0] != '\0') /* q packet recognized */
2648 while (*bufp++ == 'm') /* reply contains one or more TID */
2652 new_thread = read_ptid (bufp, &bufp);
2653 if (!ptid_equal (new_thread, null_ptid))
2655 /* In non-stop mode, we assume new found threads
2656 are running until proven otherwise with a
2657 stop reply. In all-stop, we can only get
2658 here if all threads are stopped. */
2659 int running = non_stop ? 1 : 0;
2661 remote_notice_new_inferior (new_thread, running);
2664 while (*bufp++ == ','); /* comma-separated list */
2665 putpkt ("qsThreadInfo");
2666 getpkt (&rs->buf, &rs->buf_size, 0);
2673 /* Only qfThreadInfo is supported in non-stop mode. */
2677 /* Else fall back to old method based on jmetzler protocol. */
2678 use_threadinfo_query = 0;
2679 remote_find_new_threads ();
2684 * Collect a descriptive string about the given thread.
2685 * The target may say anything it wants to about the thread
2686 * (typically info about its blocked / runnable state, name, etc.).
2687 * This string will appear in the info threads display.
2689 * Optional: targets are not required to implement this function.
2693 remote_threads_extra_info (struct thread_info *tp)
2695 struct remote_state *rs = get_remote_state ();
2699 struct gdb_ext_thread_info threadinfo;
2700 static char display_buf[100]; /* arbitrary... */
2701 int n = 0; /* position in display_buf */
2703 if (remote_desc == 0) /* paranoia */
2704 internal_error (__FILE__, __LINE__,
2705 _("remote_threads_extra_info"));
2707 if (ptid_equal (tp->ptid, magic_null_ptid)
2708 || (ptid_get_pid (tp->ptid) != 0 && ptid_get_tid (tp->ptid) == 0))
2709 /* This is the main thread which was added by GDB. The remote
2710 server doesn't know about it. */
2713 if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
2715 struct thread_info *info = find_thread_ptid (tp->ptid);
2717 if (info && info->private)
2718 return info->private->extra;
2723 if (use_threadextra_query)
2726 char *endb = rs->buf + get_remote_packet_size ();
2728 xsnprintf (b, endb - b, "qThreadExtraInfo,");
2730 write_ptid (b, endb, tp->ptid);
2733 getpkt (&rs->buf, &rs->buf_size, 0);
2734 if (rs->buf[0] != 0)
2736 n = min (strlen (rs->buf) / 2, sizeof (display_buf));
2737 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
2738 display_buf [result] = '\0';
2743 /* If the above query fails, fall back to the old method. */
2744 use_threadextra_query = 0;
2745 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
2746 | TAG_MOREDISPLAY | TAG_DISPLAY;
2747 int_to_threadref (&id, ptid_get_tid (tp->ptid));
2748 if (remote_get_threadinfo (&id, set, &threadinfo))
2749 if (threadinfo.active)
2751 if (*threadinfo.shortname)
2752 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
2753 " Name: %s,", threadinfo.shortname);
2754 if (*threadinfo.display)
2755 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
2756 " State: %s,", threadinfo.display);
2757 if (*threadinfo.more_display)
2758 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
2759 " Priority: %s", threadinfo.more_display);
2763 /* For purely cosmetic reasons, clear up trailing commas. */
2764 if (',' == display_buf[n-1])
2765 display_buf[n-1] = ' ';
2774 remote_static_tracepoint_marker_at (CORE_ADDR addr,
2775 struct static_tracepoint_marker *marker)
2777 struct remote_state *rs = get_remote_state ();
2780 sprintf (p, "qTSTMat:");
2782 p += hexnumstr (p, addr);
2784 getpkt (&rs->buf, &rs->buf_size, 0);
2788 error (_("Remote failure reply: %s"), p);
2792 parse_static_tracepoint_marker_definition (p, &p, marker);
2800 free_current_marker (void *arg)
2802 struct static_tracepoint_marker **marker_p = arg;
2804 if (*marker_p != NULL)
2806 release_static_tracepoint_marker (*marker_p);
2813 static VEC(static_tracepoint_marker_p) *
2814 remote_static_tracepoint_markers_by_strid (const char *strid)
2816 struct remote_state *rs = get_remote_state ();
2817 VEC(static_tracepoint_marker_p) *markers = NULL;
2818 struct static_tracepoint_marker *marker = NULL;
2819 struct cleanup *old_chain;
2822 /* Ask for a first packet of static tracepoint marker
2825 getpkt (&rs->buf, &rs->buf_size, 0);
2828 error (_("Remote failure reply: %s"), p);
2830 old_chain = make_cleanup (free_current_marker, &marker);
2835 marker = XCNEW (struct static_tracepoint_marker);
2839 parse_static_tracepoint_marker_definition (p, &p, marker);
2841 if (strid == NULL || strcmp (strid, marker->str_id) == 0)
2843 VEC_safe_push (static_tracepoint_marker_p,
2849 release_static_tracepoint_marker (marker);
2850 memset (marker, 0, sizeof (*marker));
2853 while (*p++ == ','); /* comma-separated list */
2854 /* Ask for another packet of static tracepoint definition. */
2856 getpkt (&rs->buf, &rs->buf_size, 0);
2860 do_cleanups (old_chain);
2865 /* Implement the to_get_ada_task_ptid function for the remote targets. */
2868 remote_get_ada_task_ptid (long lwp, long thread)
2870 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2874 /* Restart the remote side; this is an extended protocol operation. */
2877 extended_remote_restart (void)
2879 struct remote_state *rs = get_remote_state ();
2881 /* Send the restart command; for reasons I don't understand the
2882 remote side really expects a number after the "R". */
2883 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
2886 remote_fileio_reset ();
2889 /* Clean up connection to a remote debugger. */
2892 remote_close (int quitting)
2894 if (remote_desc == NULL)
2895 return; /* already closed */
2897 /* Make sure we leave stdin registered in the event loop, and we
2898 don't leave the async SIGINT signal handler installed. */
2899 remote_terminal_ours ();
2901 serial_close (remote_desc);
2904 /* We don't have a connection to the remote stub anymore. Get rid
2905 of all the inferiors and their threads we were controlling. */
2906 discard_all_inferiors ();
2907 inferior_ptid = null_ptid;
2909 /* We're no longer interested in any of these events. */
2910 discard_pending_stop_replies (-1);
2912 if (remote_async_inferior_event_token)
2913 delete_async_event_handler (&remote_async_inferior_event_token);
2914 if (remote_async_get_pending_events_token)
2915 delete_async_event_handler (&remote_async_get_pending_events_token);
2918 /* Query the remote side for the text, data and bss offsets. */
2923 struct remote_state *rs = get_remote_state ();
2926 int lose, num_segments = 0, do_sections, do_segments;
2927 CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
2928 struct section_offsets *offs;
2929 struct symfile_segment_data *data;
2931 if (symfile_objfile == NULL)
2934 putpkt ("qOffsets");
2935 getpkt (&rs->buf, &rs->buf_size, 0);
2938 if (buf[0] == '\000')
2939 return; /* Return silently. Stub doesn't support
2943 warning (_("Remote failure reply: %s"), buf);
2947 /* Pick up each field in turn. This used to be done with scanf, but
2948 scanf will make trouble if CORE_ADDR size doesn't match
2949 conversion directives correctly. The following code will work
2950 with any size of CORE_ADDR. */
2951 text_addr = data_addr = bss_addr = 0;
2955 if (strncmp (ptr, "Text=", 5) == 0)
2958 /* Don't use strtol, could lose on big values. */
2959 while (*ptr && *ptr != ';')
2960 text_addr = (text_addr << 4) + fromhex (*ptr++);
2962 if (strncmp (ptr, ";Data=", 6) == 0)
2965 while (*ptr && *ptr != ';')
2966 data_addr = (data_addr << 4) + fromhex (*ptr++);
2971 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
2974 while (*ptr && *ptr != ';')
2975 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
2977 if (bss_addr != data_addr)
2978 warning (_("Target reported unsupported offsets: %s"), buf);
2983 else if (strncmp (ptr, "TextSeg=", 8) == 0)
2986 /* Don't use strtol, could lose on big values. */
2987 while (*ptr && *ptr != ';')
2988 text_addr = (text_addr << 4) + fromhex (*ptr++);
2991 if (strncmp (ptr, ";DataSeg=", 9) == 0)
2994 while (*ptr && *ptr != ';')
2995 data_addr = (data_addr << 4) + fromhex (*ptr++);
3003 error (_("Malformed response to offset query, %s"), buf);
3004 else if (*ptr != '\0')
3005 warning (_("Target reported unsupported offsets: %s"), buf);
3007 offs = ((struct section_offsets *)
3008 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
3009 memcpy (offs, symfile_objfile->section_offsets,
3010 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
3012 data = get_symfile_segment_data (symfile_objfile->obfd);
3013 do_segments = (data != NULL);
3014 do_sections = num_segments == 0;
3016 if (num_segments > 0)
3018 segments[0] = text_addr;
3019 segments[1] = data_addr;
3021 /* If we have two segments, we can still try to relocate everything
3022 by assuming that the .text and .data offsets apply to the whole
3023 text and data segments. Convert the offsets given in the packet
3024 to base addresses for symfile_map_offsets_to_segments. */
3025 else if (data && data->num_segments == 2)
3027 segments[0] = data->segment_bases[0] + text_addr;
3028 segments[1] = data->segment_bases[1] + data_addr;
3031 /* If the object file has only one segment, assume that it is text
3032 rather than data; main programs with no writable data are rare,
3033 but programs with no code are useless. Of course the code might
3034 have ended up in the data segment... to detect that we would need
3035 the permissions here. */
3036 else if (data && data->num_segments == 1)
3038 segments[0] = data->segment_bases[0] + text_addr;
3041 /* There's no way to relocate by segment. */
3047 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
3048 offs, num_segments, segments);
3050 if (ret == 0 && !do_sections)
3051 error (_("Can not handle qOffsets TextSeg "
3052 "response with this symbol file"));
3059 free_symfile_segment_data (data);
3063 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
3065 /* This is a temporary kludge to force data and bss to use the
3066 same offsets because that's what nlmconv does now. The real
3067 solution requires changes to the stub and remote.c that I
3068 don't have time to do right now. */
3070 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
3071 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
3074 objfile_relocate (symfile_objfile, offs);
3077 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in
3078 threads we know are stopped already. This is used during the
3079 initial remote connection in non-stop mode --- threads that are
3080 reported as already being stopped are left stopped. */
3083 set_stop_requested_callback (struct thread_info *thread, void *data)
3085 /* If we have a stop reply for this thread, it must be stopped. */
3086 if (peek_stop_reply (thread->ptid))
3087 set_stop_requested (thread->ptid, 1);
3092 /* Stub for catch_exception. */
3094 struct start_remote_args
3098 /* The current target. */
3099 struct target_ops *target;
3101 /* Non-zero if this is an extended-remote target. */
3105 /* Send interrupt_sequence to remote target. */
3107 send_interrupt_sequence ()
3109 if (interrupt_sequence_mode == interrupt_sequence_control_c)
3110 serial_write (remote_desc, "\x03", 1);
3111 else if (interrupt_sequence_mode == interrupt_sequence_break)
3112 serial_send_break (remote_desc);
3113 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
3115 serial_send_break (remote_desc);
3116 serial_write (remote_desc, "g", 1);
3119 internal_error (__FILE__, __LINE__,
3120 _("Invalid value for interrupt_sequence_mode: %s."),
3121 interrupt_sequence_mode);
3125 remote_start_remote (struct ui_out *uiout, void *opaque)
3127 struct start_remote_args *args = opaque;
3128 struct remote_state *rs = get_remote_state ();
3129 struct packet_config *noack_config;
3130 char *wait_status = NULL;
3132 immediate_quit++; /* Allow user to interrupt it. */
3134 /* Ack any packet which the remote side has already sent. */
3135 serial_write (remote_desc, "+", 1);
3137 if (interrupt_on_connect)
3138 send_interrupt_sequence ();
3140 /* The first packet we send to the target is the optional "supported
3141 packets" request. If the target can answer this, it will tell us
3142 which later probes to skip. */
3143 remote_query_supported ();
3145 /* If the stub wants to get a QAllow, compose one and send it. */
3146 if (remote_protocol_packets[PACKET_QAllow].support != PACKET_DISABLE)
3147 remote_set_permissions ();
3149 /* Next, we possibly activate noack mode.
3151 If the QStartNoAckMode packet configuration is set to AUTO,
3152 enable noack mode if the stub reported a wish for it with
3155 If set to TRUE, then enable noack mode even if the stub didn't
3156 report it in qSupported. If the stub doesn't reply OK, the
3157 session ends with an error.
3159 If FALSE, then don't activate noack mode, regardless of what the
3160 stub claimed should be the default with qSupported. */
3162 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
3164 if (noack_config->detect == AUTO_BOOLEAN_TRUE
3165 || (noack_config->detect == AUTO_BOOLEAN_AUTO
3166 && noack_config->support == PACKET_ENABLE))
3168 putpkt ("QStartNoAckMode");
3169 getpkt (&rs->buf, &rs->buf_size, 0);
3170 if (packet_ok (rs->buf, noack_config) == PACKET_OK)
3174 if (args->extended_p)
3176 /* Tell the remote that we are using the extended protocol. */
3178 getpkt (&rs->buf, &rs->buf_size, 0);
3181 /* Next, if the target can specify a description, read it. We do
3182 this before anything involving memory or registers. */
3183 target_find_description ();
3185 /* Next, now that we know something about the target, update the
3186 address spaces in the program spaces. */
3187 update_address_spaces ();
3189 /* On OSs where the list of libraries is global to all
3190 processes, we fetch them early. */
3191 if (gdbarch_has_global_solist (target_gdbarch))
3192 solib_add (NULL, args->from_tty, args->target, auto_solib_add);
3196 if (!rs->non_stop_aware)
3197 error (_("Non-stop mode requested, but remote "
3198 "does not support non-stop"));
3200 putpkt ("QNonStop:1");
3201 getpkt (&rs->buf, &rs->buf_size, 0);
3203 if (strcmp (rs->buf, "OK") != 0)
3204 error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
3206 /* Find about threads and processes the stub is already
3207 controlling. We default to adding them in the running state.
3208 The '?' query below will then tell us about which threads are
3210 remote_threads_info (args->target);
3212 else if (rs->non_stop_aware)
3214 /* Don't assume that the stub can operate in all-stop mode.
3215 Request it explicitely. */
3216 putpkt ("QNonStop:0");
3217 getpkt (&rs->buf, &rs->buf_size, 0);
3219 if (strcmp (rs->buf, "OK") != 0)
3220 error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
3223 /* Check whether the target is running now. */
3225 getpkt (&rs->buf, &rs->buf_size, 0);
3229 if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
3231 if (!args->extended_p)
3232 error (_("The target is not running (try extended-remote?)"));
3234 /* We're connected, but not running. Drop out before we
3235 call start_remote. */
3240 /* Save the reply for later. */
3241 wait_status = alloca (strlen (rs->buf) + 1);
3242 strcpy (wait_status, rs->buf);
3245 /* Let the stub know that we want it to return the thread. */
3246 set_continue_thread (minus_one_ptid);
3248 /* Without this, some commands which require an active target
3249 (such as kill) won't work. This variable serves (at least)
3250 double duty as both the pid of the target process (if it has
3251 such), and as a flag indicating that a target is active.
3252 These functions should be split out into seperate variables,
3253 especially since GDB will someday have a notion of debugging
3254 several processes. */
3255 inferior_ptid = magic_null_ptid;
3257 /* Now, if we have thread information, update inferior_ptid. */
3258 inferior_ptid = remote_current_thread (inferior_ptid);
3260 remote_add_inferior (ptid_get_pid (inferior_ptid), -1);
3262 /* Always add the main thread. */
3263 add_thread_silent (inferior_ptid);
3265 get_offsets (); /* Get text, data & bss offsets. */
3267 /* If we could not find a description using qXfer, and we know
3268 how to do it some other way, try again. This is not
3269 supported for non-stop; it could be, but it is tricky if
3270 there are no stopped threads when we connect. */
3271 if (remote_read_description_p (args->target)
3272 && gdbarch_target_desc (target_gdbarch) == NULL)
3274 target_clear_description ();
3275 target_find_description ();
3278 /* Use the previously fetched status. */
3279 gdb_assert (wait_status != NULL);
3280 strcpy (rs->buf, wait_status);
3281 rs->cached_wait_status = 1;
3284 start_remote (args->from_tty); /* Initialize gdb process mechanisms. */
3288 /* Clear WFI global state. Do this before finding about new
3289 threads and inferiors, and setting the current inferior.
3290 Otherwise we would clear the proceed status of the current
3291 inferior when we want its stop_soon state to be preserved
3292 (see notice_new_inferior). */
3293 init_wait_for_inferior ();
3295 /* In non-stop, we will either get an "OK", meaning that there
3296 are no stopped threads at this time; or, a regular stop
3297 reply. In the latter case, there may be more than one thread
3298 stopped --- we pull them all out using the vStopped
3300 if (strcmp (rs->buf, "OK") != 0)
3302 struct stop_reply *stop_reply;
3303 struct cleanup *old_chain;
3305 stop_reply = stop_reply_xmalloc ();
3306 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply);
3308 remote_parse_stop_reply (rs->buf, stop_reply);
3309 discard_cleanups (old_chain);
3311 /* get_pending_stop_replies acks this one, and gets the rest
3313 pending_stop_reply = stop_reply;
3314 remote_get_pending_stop_replies ();
3316 /* Make sure that threads that were stopped remain
3318 iterate_over_threads (set_stop_requested_callback, NULL);
3321 if (target_can_async_p ())
3322 target_async (inferior_event_handler, 0);
3324 if (thread_count () == 0)
3326 if (!args->extended_p)
3327 error (_("The target is not running (try extended-remote?)"));
3329 /* We're connected, but not running. Drop out before we
3330 call start_remote. */
3334 /* Let the stub know that we want it to return the thread. */
3336 /* Force the stub to choose a thread. */
3337 set_general_thread (null_ptid);
3340 inferior_ptid = remote_current_thread (minus_one_ptid);
3341 if (ptid_equal (inferior_ptid, minus_one_ptid))
3342 error (_("remote didn't report the current thread in non-stop mode"));
3344 get_offsets (); /* Get text, data & bss offsets. */
3346 /* In non-stop mode, any cached wait status will be stored in
3347 the stop reply queue. */
3348 gdb_assert (wait_status == NULL);
3350 /* Update the remote on signals to silently pass, or more
3351 importantly, which to not ignore, in case a previous session
3352 had set some different set of signals to be ignored. */
3353 remote_pass_signals ();
3356 /* If we connected to a live target, do some additional setup. */
3357 if (target_has_execution)
3359 if (exec_bfd) /* No use without an exec file. */
3360 remote_check_symbols (symfile_objfile);
3363 /* Possibly the target has been engaged in a trace run started
3364 previously; find out where things are at. */
3365 if (remote_get_trace_status (current_trace_status ()) != -1)
3367 struct uploaded_tp *uploaded_tps = NULL;
3368 struct uploaded_tsv *uploaded_tsvs = NULL;
3370 if (current_trace_status ()->running)
3371 printf_filtered (_("Trace is already running on the target.\n"));
3373 /* Get trace state variables first, they may be checked when
3374 parsing uploaded commands. */
3376 remote_upload_trace_state_variables (&uploaded_tsvs);
3378 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3380 remote_upload_tracepoints (&uploaded_tps);
3382 merge_uploaded_tracepoints (&uploaded_tps);
3385 /* If breakpoints are global, insert them now. */
3386 if (gdbarch_has_global_breakpoints (target_gdbarch)
3387 && breakpoints_always_inserted_mode ())
3388 insert_breakpoints ();
3391 /* Open a connection to a remote debugger.
3392 NAME is the filename used for communication. */
3395 remote_open (char *name, int from_tty)
3397 remote_open_1 (name, from_tty, &remote_ops, 0);
3400 /* Open a connection to a remote debugger using the extended
3401 remote gdb protocol. NAME is the filename used for communication. */
3404 extended_remote_open (char *name, int from_tty)
3406 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
3409 /* Generic code for opening a connection to a remote target. */
3412 init_all_packet_configs (void)
3416 for (i = 0; i < PACKET_MAX; i++)
3417 update_packet_config (&remote_protocol_packets[i]);
3420 /* Symbol look-up. */
3423 remote_check_symbols (struct objfile *objfile)
3425 struct remote_state *rs = get_remote_state ();
3426 char *msg, *reply, *tmp;
3427 struct minimal_symbol *sym;
3430 if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
3433 /* Make sure the remote is pointing at the right process. */
3434 set_general_process ();
3436 /* Allocate a message buffer. We can't reuse the input buffer in RS,
3437 because we need both at the same time. */
3438 msg = alloca (get_remote_packet_size ());
3440 /* Invite target to request symbol lookups. */
3442 putpkt ("qSymbol::");
3443 getpkt (&rs->buf, &rs->buf_size, 0);
3444 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
3447 while (strncmp (reply, "qSymbol:", 8) == 0)
3450 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
3452 sym = lookup_minimal_symbol (msg, NULL, NULL);
3454 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
3457 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
3458 CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
3460 /* If this is a function address, return the start of code
3461 instead of any data function descriptor. */
3462 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
3466 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
3467 phex_nz (sym_addr, addr_size), &reply[8]);
3471 getpkt (&rs->buf, &rs->buf_size, 0);
3476 static struct serial *
3477 remote_serial_open (char *name)
3479 static int udp_warning = 0;
3481 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
3482 of in ser-tcp.c, because it is the remote protocol assuming that the
3483 serial connection is reliable and not the serial connection promising
3485 if (!udp_warning && strncmp (name, "udp:", 4) == 0)
3487 warning (_("The remote protocol may be unreliable over UDP.\n"
3488 "Some events may be lost, rendering further debugging "
3493 return serial_open (name);
3496 /* Inform the target of our permission settings. The permission flags
3497 work without this, but if the target knows the settings, it can do
3498 a couple things. First, it can add its own check, to catch cases
3499 that somehow manage to get by the permissions checks in target
3500 methods. Second, if the target is wired to disallow particular
3501 settings (for instance, a system in the field that is not set up to
3502 be able to stop at a breakpoint), it can object to any unavailable
3506 remote_set_permissions (void)
3508 struct remote_state *rs = get_remote_state ();
3510 sprintf (rs->buf, "QAllow:"
3511 "WriteReg:%x;WriteMem:%x;"
3512 "InsertBreak:%x;InsertTrace:%x;"
3513 "InsertFastTrace:%x;Stop:%x",
3514 may_write_registers, may_write_memory,
3515 may_insert_breakpoints, may_insert_tracepoints,
3516 may_insert_fast_tracepoints, may_stop);
3518 getpkt (&rs->buf, &rs->buf_size, 0);
3520 /* If the target didn't like the packet, warn the user. Do not try
3521 to undo the user's settings, that would just be maddening. */
3522 if (strcmp (rs->buf, "OK") != 0)
3523 warning ("Remote refused setting permissions with: %s", rs->buf);
3526 /* This type describes each known response to the qSupported
3528 struct protocol_feature
3530 /* The name of this protocol feature. */
3533 /* The default for this protocol feature. */
3534 enum packet_support default_support;
3536 /* The function to call when this feature is reported, or after
3537 qSupported processing if the feature is not supported.
3538 The first argument points to this structure. The second
3539 argument indicates whether the packet requested support be
3540 enabled, disabled, or probed (or the default, if this function
3541 is being called at the end of processing and this feature was
3542 not reported). The third argument may be NULL; if not NULL, it
3543 is a NUL-terminated string taken from the packet following
3544 this feature's name and an equals sign. */
3545 void (*func) (const struct protocol_feature *, enum packet_support,
3548 /* The corresponding packet for this feature. Only used if
3549 FUNC is remote_supported_packet. */
3554 remote_supported_packet (const struct protocol_feature *feature,
3555 enum packet_support support,
3556 const char *argument)
3560 warning (_("Remote qSupported response supplied an unexpected value for"
3561 " \"%s\"."), feature->name);
3565 if (remote_protocol_packets[feature->packet].support
3566 == PACKET_SUPPORT_UNKNOWN)
3567 remote_protocol_packets[feature->packet].support = support;
3571 remote_packet_size (const struct protocol_feature *feature,
3572 enum packet_support support, const char *value)
3574 struct remote_state *rs = get_remote_state ();
3579 if (support != PACKET_ENABLE)
3582 if (value == NULL || *value == '\0')
3584 warning (_("Remote target reported \"%s\" without a size."),
3590 packet_size = strtol (value, &value_end, 16);
3591 if (errno != 0 || *value_end != '\0' || packet_size < 0)
3593 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
3594 feature->name, value);
3598 if (packet_size > MAX_REMOTE_PACKET_SIZE)
3600 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
3601 packet_size, MAX_REMOTE_PACKET_SIZE);
3602 packet_size = MAX_REMOTE_PACKET_SIZE;
3605 /* Record the new maximum packet size. */
3606 rs->explicit_packet_size = packet_size;
3610 remote_multi_process_feature (const struct protocol_feature *feature,
3611 enum packet_support support, const char *value)
3613 struct remote_state *rs = get_remote_state ();
3615 rs->multi_process_aware = (support == PACKET_ENABLE);
3619 remote_non_stop_feature (const struct protocol_feature *feature,
3620 enum packet_support support, const char *value)
3622 struct remote_state *rs = get_remote_state ();
3624 rs->non_stop_aware = (support == PACKET_ENABLE);
3628 remote_cond_tracepoint_feature (const struct protocol_feature *feature,
3629 enum packet_support support,
3632 struct remote_state *rs = get_remote_state ();
3634 rs->cond_tracepoints = (support == PACKET_ENABLE);
3638 remote_fast_tracepoint_feature (const struct protocol_feature *feature,
3639 enum packet_support support,
3642 struct remote_state *rs = get_remote_state ();
3644 rs->fast_tracepoints = (support == PACKET_ENABLE);
3648 remote_static_tracepoint_feature (const struct protocol_feature *feature,
3649 enum packet_support support,
3652 struct remote_state *rs = get_remote_state ();
3654 rs->static_tracepoints = (support == PACKET_ENABLE);
3658 remote_disconnected_tracing_feature (const struct protocol_feature *feature,
3659 enum packet_support support,
3662 struct remote_state *rs = get_remote_state ();
3664 rs->disconnected_tracing = (support == PACKET_ENABLE);
3667 static struct protocol_feature remote_protocol_features[] = {
3668 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
3669 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
3670 PACKET_qXfer_auxv },
3671 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
3672 PACKET_qXfer_features },
3673 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
3674 PACKET_qXfer_libraries },
3675 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
3676 PACKET_qXfer_memory_map },
3677 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
3678 PACKET_qXfer_spu_read },
3679 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
3680 PACKET_qXfer_spu_write },
3681 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
3682 PACKET_qXfer_osdata },
3683 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
3684 PACKET_qXfer_threads },
3685 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
3686 PACKET_QPassSignals },
3687 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
3688 PACKET_QStartNoAckMode },
3689 { "multiprocess", PACKET_DISABLE, remote_multi_process_feature, -1 },
3690 { "QNonStop", PACKET_DISABLE, remote_non_stop_feature, -1 },
3691 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
3692 PACKET_qXfer_siginfo_read },
3693 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
3694 PACKET_qXfer_siginfo_write },
3695 { "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature,
3696 PACKET_ConditionalTracepoints },
3697 { "FastTracepoints", PACKET_DISABLE, remote_fast_tracepoint_feature,
3698 PACKET_FastTracepoints },
3699 { "StaticTracepoints", PACKET_DISABLE, remote_static_tracepoint_feature,
3700 PACKET_StaticTracepoints },
3701 { "DisconnectedTracing", PACKET_DISABLE, remote_disconnected_tracing_feature,
3703 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
3705 { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
3707 { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
3708 PACKET_TracepointSource },
3709 { "QAllow", PACKET_DISABLE, remote_supported_packet,
3713 static char *remote_support_xml;
3715 /* Register string appended to "xmlRegisters=" in qSupported query. */
3718 register_remote_support_xml (const char *xml)
3720 #if defined(HAVE_LIBEXPAT)
3721 if (remote_support_xml == NULL)
3722 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
3725 char *copy = xstrdup (remote_support_xml + 13);
3726 char *p = strtok (copy, ",");
3730 if (strcmp (p, xml) == 0)
3737 while ((p = strtok (NULL, ",")) != NULL);
3740 remote_support_xml = reconcat (remote_support_xml,
3741 remote_support_xml, ",", xml,
3748 remote_query_supported_append (char *msg, const char *append)
3751 return reconcat (msg, msg, ";", append, (char *) NULL);
3753 return xstrdup (append);
3757 remote_query_supported (void)
3759 struct remote_state *rs = get_remote_state ();
3762 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
3764 /* The packet support flags are handled differently for this packet
3765 than for most others. We treat an error, a disabled packet, and
3766 an empty response identically: any features which must be reported
3767 to be used will be automatically disabled. An empty buffer
3768 accomplishes this, since that is also the representation for a list
3769 containing no features. */
3772 if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
3775 struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
3778 q = remote_query_supported_append (q, "multiprocess+");
3780 if (remote_support_xml)
3781 q = remote_query_supported_append (q, remote_support_xml);
3783 q = remote_query_supported_append (q, "qRelocInsn+");
3785 q = reconcat (q, "qSupported:", q, (char *) NULL);
3788 do_cleanups (old_chain);
3790 getpkt (&rs->buf, &rs->buf_size, 0);
3792 /* If an error occured, warn, but do not return - just reset the
3793 buffer to empty and go on to disable features. */
3794 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
3797 warning (_("Remote failure reply: %s"), rs->buf);
3802 memset (seen, 0, sizeof (seen));
3807 enum packet_support is_supported;
3808 char *p, *end, *name_end, *value;
3810 /* First separate out this item from the rest of the packet. If
3811 there's another item after this, we overwrite the separator
3812 (terminated strings are much easier to work with). */
3814 end = strchr (p, ';');
3817 end = p + strlen (p);
3827 warning (_("empty item in \"qSupported\" response"));
3832 name_end = strchr (p, '=');
3835 /* This is a name=value entry. */
3836 is_supported = PACKET_ENABLE;
3837 value = name_end + 1;
3846 is_supported = PACKET_ENABLE;
3850 is_supported = PACKET_DISABLE;
3854 is_supported = PACKET_SUPPORT_UNKNOWN;
3858 warning (_("unrecognized item \"%s\" "
3859 "in \"qSupported\" response"), p);
3865 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
3866 if (strcmp (remote_protocol_features[i].name, p) == 0)
3868 const struct protocol_feature *feature;
3871 feature = &remote_protocol_features[i];
3872 feature->func (feature, is_supported, value);
3877 /* If we increased the packet size, make sure to increase the global
3878 buffer size also. We delay this until after parsing the entire
3879 qSupported packet, because this is the same buffer we were
3881 if (rs->buf_size < rs->explicit_packet_size)
3883 rs->buf_size = rs->explicit_packet_size;
3884 rs->buf = xrealloc (rs->buf, rs->buf_size);
3887 /* Handle the defaults for unmentioned features. */
3888 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
3891 const struct protocol_feature *feature;
3893 feature = &remote_protocol_features[i];
3894 feature->func (feature, feature->default_support, NULL);
3900 remote_open_1 (char *name, int from_tty,
3901 struct target_ops *target, int extended_p)
3903 struct remote_state *rs = get_remote_state ();
3906 error (_("To open a remote debug connection, you need to specify what\n"
3907 "serial device is attached to the remote system\n"
3908 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
3910 /* See FIXME above. */
3911 if (!target_async_permitted)
3912 wait_forever_enabled_p = 1;
3914 /* If we're connected to a running target, target_preopen will kill it.
3915 But if we're connected to a target system with no running process,
3916 then we will still be connected when it returns. Ask this question
3917 first, before target_preopen has a chance to kill anything. */
3918 if (remote_desc != NULL && !have_inferiors ())
3921 || query (_("Already connected to a remote target. Disconnect? ")))
3924 error (_("Still connected."));
3927 target_preopen (from_tty);
3929 unpush_target (target);
3931 /* This time without a query. If we were connected to an
3932 extended-remote target and target_preopen killed the running
3933 process, we may still be connected. If we are starting "target
3934 remote" now, the extended-remote target will not have been
3935 removed by unpush_target. */
3936 if (remote_desc != NULL && !have_inferiors ())
3939 /* Make sure we send the passed signals list the next time we resume. */
3940 xfree (last_pass_packet);
3941 last_pass_packet = NULL;
3943 remote_fileio_reset ();
3944 reopen_exec_file ();
3947 remote_desc = remote_serial_open (name);
3949 perror_with_name (name);
3951 if (baud_rate != -1)
3953 if (serial_setbaudrate (remote_desc, baud_rate))
3955 /* The requested speed could not be set. Error out to
3956 top level after closing remote_desc. Take care to
3957 set remote_desc to NULL to avoid closing remote_desc
3959 serial_close (remote_desc);
3961 perror_with_name (name);
3965 serial_raw (remote_desc);
3967 /* If there is something sitting in the buffer we might take it as a
3968 response to a command, which would be bad. */
3969 serial_flush_input (remote_desc);
3973 puts_filtered ("Remote debugging using ");
3974 puts_filtered (name);
3975 puts_filtered ("\n");
3977 push_target (target); /* Switch to using remote target now. */
3979 /* Register extra event sources in the event loop. */
3980 remote_async_inferior_event_token
3981 = create_async_event_handler (remote_async_inferior_event_handler,
3983 remote_async_get_pending_events_token
3984 = create_async_event_handler (remote_async_get_pending_events_handler,
3987 /* Reset the target state; these things will be queried either by
3988 remote_query_supported or as they are needed. */
3989 init_all_packet_configs ();
3990 rs->cached_wait_status = 0;
3991 rs->explicit_packet_size = 0;
3993 rs->multi_process_aware = 0;
3994 rs->extended = extended_p;
3995 rs->non_stop_aware = 0;
3996 rs->waiting_for_stop_reply = 0;
3997 rs->ctrlc_pending_p = 0;
3999 general_thread = not_sent_ptid;
4000 continue_thread = not_sent_ptid;
4002 /* Probe for ability to use "ThreadInfo" query, as required. */
4003 use_threadinfo_query = 1;
4004 use_threadextra_query = 1;
4006 if (target_async_permitted)
4008 /* With this target we start out by owning the terminal. */
4009 remote_async_terminal_ours_p = 1;
4011 /* FIXME: cagney/1999-09-23: During the initial connection it is
4012 assumed that the target is already ready and able to respond to
4013 requests. Unfortunately remote_start_remote() eventually calls
4014 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
4015 around this. Eventually a mechanism that allows
4016 wait_for_inferior() to expect/get timeouts will be
4018 wait_forever_enabled_p = 0;
4021 /* First delete any symbols previously loaded from shared libraries. */
4022 no_shared_libraries (NULL, 0);
4025 init_thread_list ();
4027 /* Start the remote connection. If error() or QUIT, discard this
4028 target (we'd otherwise be in an inconsistent state) and then
4029 propogate the error on up the exception chain. This ensures that
4030 the caller doesn't stumble along blindly assuming that the
4031 function succeeded. The CLI doesn't have this problem but other
4032 UI's, such as MI do.
4034 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
4035 this function should return an error indication letting the
4036 caller restore the previous state. Unfortunately the command
4037 ``target remote'' is directly wired to this function making that
4038 impossible. On a positive note, the CLI side of this problem has
4039 been fixed - the function set_cmd_context() makes it possible for
4040 all the ``target ....'' commands to share a common callback
4041 function. See cli-dump.c. */
4043 struct gdb_exception ex;
4044 struct start_remote_args args;
4046 args.from_tty = from_tty;
4047 args.target = target;
4048 args.extended_p = extended_p;
4050 ex = catch_exception (uiout, remote_start_remote, &args, RETURN_MASK_ALL);
4053 /* Pop the partially set up target - unless something else did
4054 already before throwing the exception. */
4055 if (remote_desc != NULL)
4057 if (target_async_permitted)
4058 wait_forever_enabled_p = 1;
4059 throw_exception (ex);
4063 if (target_async_permitted)
4064 wait_forever_enabled_p = 1;
4067 /* This takes a program previously attached to and detaches it. After
4068 this is done, GDB can be used to debug some other program. We
4069 better not have left any breakpoints in the target program or it'll
4070 die when it hits one. */
4073 remote_detach_1 (char *args, int from_tty, int extended)
4075 int pid = ptid_get_pid (inferior_ptid);
4076 struct remote_state *rs = get_remote_state ();
4079 error (_("Argument given to \"detach\" when remotely debugging."));
4081 if (!target_has_execution)
4082 error (_("No process to detach from."));
4084 /* Tell the remote target to detach. */
4085 if (remote_multi_process_p (rs))
4086 sprintf (rs->buf, "D;%x", pid);
4088 strcpy (rs->buf, "D");
4091 getpkt (&rs->buf, &rs->buf_size, 0);
4093 if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
4095 else if (rs->buf[0] == '\0')
4096 error (_("Remote doesn't know how to detach"));
4098 error (_("Can't detach process."));
4102 if (remote_multi_process_p (rs))
4103 printf_filtered (_("Detached from remote %s.\n"),
4104 target_pid_to_str (pid_to_ptid (pid)));
4108 puts_filtered (_("Detached from remote process.\n"));
4110 puts_filtered (_("Ending remote debugging.\n"));
4114 discard_pending_stop_replies (pid);
4115 target_mourn_inferior ();
4119 remote_detach (struct target_ops *ops, char *args, int from_tty)
4121 remote_detach_1 (args, from_tty, 0);
4125 extended_remote_detach (struct target_ops *ops, char *args, int from_tty)
4127 remote_detach_1 (args, from_tty, 1);
4130 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
4133 remote_disconnect (struct target_ops *target, char *args, int from_tty)
4136 error (_("Argument given to \"disconnect\" when remotely debugging."));
4138 /* Make sure we unpush even the extended remote targets; mourn
4139 won't do it. So call remote_mourn_1 directly instead of
4140 target_mourn_inferior. */
4141 remote_mourn_1 (target);
4144 puts_filtered ("Ending remote debugging.\n");
4147 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
4148 be chatty about it. */
4151 extended_remote_attach_1 (struct target_ops *target, char *args, int from_tty)
4153 struct remote_state *rs = get_remote_state ();
4155 char *wait_status = NULL;
4157 pid = parse_pid_to_attach (args);
4159 /* Remote PID can be freely equal to getpid, do not check it here the same
4160 way as in other targets. */
4162 if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
4163 error (_("This target does not support attaching to a process"));
4165 sprintf (rs->buf, "vAttach;%x", pid);
4167 getpkt (&rs->buf, &rs->buf_size, 0);
4169 if (packet_ok (rs->buf,
4170 &remote_protocol_packets[PACKET_vAttach]) == PACKET_OK)
4173 printf_unfiltered (_("Attached to %s\n"),
4174 target_pid_to_str (pid_to_ptid (pid)));
4178 /* Save the reply for later. */
4179 wait_status = alloca (strlen (rs->buf) + 1);
4180 strcpy (wait_status, rs->buf);
4182 else if (strcmp (rs->buf, "OK") != 0)
4183 error (_("Attaching to %s failed with: %s"),
4184 target_pid_to_str (pid_to_ptid (pid)),
4187 else if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
4188 error (_("This target does not support attaching to a process"));
4190 error (_("Attaching to %s failed"),
4191 target_pid_to_str (pid_to_ptid (pid)));
4193 set_current_inferior (remote_add_inferior (pid, 1));
4195 inferior_ptid = pid_to_ptid (pid);
4199 struct thread_info *thread;
4201 /* Get list of threads. */
4202 remote_threads_info (target);
4204 thread = first_thread_of_process (pid);
4206 inferior_ptid = thread->ptid;
4208 inferior_ptid = pid_to_ptid (pid);
4210 /* Invalidate our notion of the remote current thread. */
4211 record_currthread (minus_one_ptid);
4215 /* Now, if we have thread information, update inferior_ptid. */
4216 inferior_ptid = remote_current_thread (inferior_ptid);
4218 /* Add the main thread to the thread list. */
4219 add_thread_silent (inferior_ptid);
4222 /* Next, if the target can specify a description, read it. We do
4223 this before anything involving memory or registers. */
4224 target_find_description ();
4228 /* Use the previously fetched status. */
4229 gdb_assert (wait_status != NULL);
4231 if (target_can_async_p ())
4233 struct stop_reply *stop_reply;
4234 struct cleanup *old_chain;
4236 stop_reply = stop_reply_xmalloc ();
4237 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply);
4238 remote_parse_stop_reply (wait_status, stop_reply);
4239 discard_cleanups (old_chain);
4240 push_stop_reply (stop_reply);
4242 target_async (inferior_event_handler, 0);
4246 gdb_assert (wait_status != NULL);
4247 strcpy (rs->buf, wait_status);
4248 rs->cached_wait_status = 1;
4252 gdb_assert (wait_status == NULL);
4256 extended_remote_attach (struct target_ops *ops, char *args, int from_tty)
4258 extended_remote_attach_1 (ops, args, from_tty);
4261 /* Convert hex digit A to a number. */
4266 if (a >= '0' && a <= '9')
4268 else if (a >= 'a' && a <= 'f')
4269 return a - 'a' + 10;
4270 else if (a >= 'A' && a <= 'F')
4271 return a - 'A' + 10;
4273 error (_("Reply contains invalid hex digit %d"), a);
4277 hex2bin (const char *hex, gdb_byte *bin, int count)
4281 for (i = 0; i < count; i++)
4283 if (hex[0] == 0 || hex[1] == 0)
4285 /* Hex string is short, or of uneven length.
4286 Return the count that has been converted so far. */
4289 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
4295 /* Convert number NIB to a hex digit. */
4303 return 'a' + nib - 10;
4307 bin2hex (const gdb_byte *bin, char *hex, int count)
4311 /* May use a length, or a nul-terminated string as input. */
4313 count = strlen ((char *) bin);
4315 for (i = 0; i < count; i++)
4317 *hex++ = tohex ((*bin >> 4) & 0xf);
4318 *hex++ = tohex (*bin++ & 0xf);
4324 /* Check for the availability of vCont. This function should also check
4328 remote_vcont_probe (struct remote_state *rs)
4332 strcpy (rs->buf, "vCont?");
4334 getpkt (&rs->buf, &rs->buf_size, 0);
4337 /* Make sure that the features we assume are supported. */
4338 if (strncmp (buf, "vCont", 5) == 0)
4341 int support_s, support_S, support_c, support_C;
4347 rs->support_vCont_t = 0;
4348 while (p && *p == ';')
4351 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
4353 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
4355 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
4357 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
4359 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0))
4360 rs->support_vCont_t = 1;
4362 p = strchr (p, ';');
4365 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
4366 BUF will make packet_ok disable the packet. */
4367 if (!support_s || !support_S || !support_c || !support_C)
4371 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
4374 /* Helper function for building "vCont" resumptions. Write a
4375 resumption to P. ENDP points to one-passed-the-end of the buffer
4376 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
4377 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
4378 resumed thread should be single-stepped and/or signalled. If PTID
4379 equals minus_one_ptid, then all threads are resumed; if PTID
4380 represents a process, then all threads of the process are resumed;
4381 the thread to be stepped and/or signalled is given in the global
4385 append_resumption (char *p, char *endp,
4386 ptid_t ptid, int step, enum target_signal siggnal)
4388 struct remote_state *rs = get_remote_state ();
4390 if (step && siggnal != TARGET_SIGNAL_0)
4391 p += xsnprintf (p, endp - p, ";S%02x", siggnal);
4393 p += xsnprintf (p, endp - p, ";s");
4394 else if (siggnal != TARGET_SIGNAL_0)
4395 p += xsnprintf (p, endp - p, ";C%02x", siggnal);
4397 p += xsnprintf (p, endp - p, ";c");
4399 if (remote_multi_process_p (rs) && ptid_is_pid (ptid))
4403 /* All (-1) threads of process. */
4404 nptid = ptid_build (ptid_get_pid (ptid), 0, -1);
4406 p += xsnprintf (p, endp - p, ":");
4407 p = write_ptid (p, endp, nptid);
4409 else if (!ptid_equal (ptid, minus_one_ptid))
4411 p += xsnprintf (p, endp - p, ":");
4412 p = write_ptid (p, endp, ptid);
4418 /* Resume the remote inferior by using a "vCont" packet. The thread
4419 to be resumed is PTID; STEP and SIGGNAL indicate whether the
4420 resumed thread should be single-stepped and/or signalled. If PTID
4421 equals minus_one_ptid, then all threads are resumed; the thread to
4422 be stepped and/or signalled is given in the global INFERIOR_PTID.
4423 This function returns non-zero iff it resumes the inferior.
4425 This function issues a strict subset of all possible vCont commands at the
4429 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
4431 struct remote_state *rs = get_remote_state ();
4435 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
4436 remote_vcont_probe (rs);
4438 if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
4442 endp = rs->buf + get_remote_packet_size ();
4444 /* If we could generate a wider range of packets, we'd have to worry
4445 about overflowing BUF. Should there be a generic
4446 "multi-part-packet" packet? */
4448 p += xsnprintf (p, endp - p, "vCont");
4450 if (ptid_equal (ptid, magic_null_ptid))
4452 /* MAGIC_NULL_PTID means that we don't have any active threads,
4453 so we don't have any TID numbers the inferior will
4454 understand. Make sure to only send forms that do not specify
4456 p = append_resumption (p, endp, minus_one_ptid, step, siggnal);
4458 else if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
4460 /* Resume all threads (of all processes, or of a single
4461 process), with preference for INFERIOR_PTID. This assumes
4462 inferior_ptid belongs to the set of all threads we are about
4464 if (step || siggnal != TARGET_SIGNAL_0)
4466 /* Step inferior_ptid, with or without signal. */
4467 p = append_resumption (p, endp, inferior_ptid, step, siggnal);
4470 /* And continue others without a signal. */
4471 p = append_resumption (p, endp, ptid, /*step=*/ 0, TARGET_SIGNAL_0);
4475 /* Scheduler locking; resume only PTID. */
4476 p = append_resumption (p, endp, ptid, step, siggnal);
4479 gdb_assert (strlen (rs->buf) < get_remote_packet_size ());
4484 /* In non-stop, the stub replies to vCont with "OK". The stop
4485 reply will be reported asynchronously by means of a `%Stop'
4487 getpkt (&rs->buf, &rs->buf_size, 0);
4488 if (strcmp (rs->buf, "OK") != 0)
4489 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
4495 /* Tell the remote machine to resume. */
4497 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
4499 static int last_sent_step;
4502 remote_resume (struct target_ops *ops,
4503 ptid_t ptid, int step, enum target_signal siggnal)
4505 struct remote_state *rs = get_remote_state ();
4508 last_sent_signal = siggnal;
4509 last_sent_step = step;
4511 /* Update the inferior on signals to silently pass, if they've changed. */
4512 remote_pass_signals ();
4514 /* The vCont packet doesn't need to specify threads via Hc. */
4515 /* No reverse support (yet) for vCont. */
4516 if (execution_direction != EXEC_REVERSE)
4517 if (remote_vcont_resume (ptid, step, siggnal))
4520 /* All other supported resume packets do use Hc, so set the continue
4522 if (ptid_equal (ptid, minus_one_ptid))
4523 set_continue_thread (any_thread_ptid);
4525 set_continue_thread (ptid);
4528 if (execution_direction == EXEC_REVERSE)
4530 /* We don't pass signals to the target in reverse exec mode. */
4531 if (info_verbose && siggnal != TARGET_SIGNAL_0)
4532 warning (" - Can't pass signal %d to target in reverse: ignored.\n",
4536 && remote_protocol_packets[PACKET_bs].support == PACKET_DISABLE)
4537 error (_("Remote reverse-step not supported."));
4539 && remote_protocol_packets[PACKET_bc].support == PACKET_DISABLE)
4540 error (_("Remote reverse-continue not supported."));
4542 strcpy (buf, step ? "bs" : "bc");
4544 else if (siggnal != TARGET_SIGNAL_0)
4546 buf[0] = step ? 'S' : 'C';
4547 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
4548 buf[2] = tohex (((int) siggnal) & 0xf);
4552 strcpy (buf, step ? "s" : "c");
4557 /* We are about to start executing the inferior, let's register it
4558 with the event loop. NOTE: this is the one place where all the
4559 execution commands end up. We could alternatively do this in each
4560 of the execution commands in infcmd.c. */
4561 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
4562 into infcmd.c in order to allow inferior function calls to work
4563 NOT asynchronously. */
4564 if (target_can_async_p ())
4565 target_async (inferior_event_handler, 0);
4567 /* We've just told the target to resume. The remote server will
4568 wait for the inferior to stop, and then send a stop reply. In
4569 the mean time, we can't start another command/query ourselves
4570 because the stub wouldn't be ready to process it. This applies
4571 only to the base all-stop protocol, however. In non-stop (which
4572 only supports vCont), the stub replies with an "OK", and is
4573 immediate able to process further serial input. */
4575 rs->waiting_for_stop_reply = 1;
4579 /* Set up the signal handler for SIGINT, while the target is
4580 executing, ovewriting the 'regular' SIGINT signal handler. */
4582 initialize_sigint_signal_handler (void)
4584 signal (SIGINT, handle_remote_sigint);
4587 /* Signal handler for SIGINT, while the target is executing. */
4589 handle_remote_sigint (int sig)
4591 signal (sig, handle_remote_sigint_twice);
4592 mark_async_signal_handler_wrapper (sigint_remote_token);
4595 /* Signal handler for SIGINT, installed after SIGINT has already been
4596 sent once. It will take effect the second time that the user sends
4599 handle_remote_sigint_twice (int sig)
4601 signal (sig, handle_remote_sigint);
4602 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
4605 /* Perform the real interruption of the target execution, in response
4608 async_remote_interrupt (gdb_client_data arg)
4611 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
4613 target_stop (inferior_ptid);
4616 /* Perform interrupt, if the first attempt did not succeed. Just give
4617 up on the target alltogether. */
4619 async_remote_interrupt_twice (gdb_client_data arg)
4622 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
4627 /* Reinstall the usual SIGINT handlers, after the target has
4630 cleanup_sigint_signal_handler (void *dummy)
4632 signal (SIGINT, handle_sigint);
4635 /* Send ^C to target to halt it. Target will respond, and send us a
4637 static void (*ofunc) (int);
4639 /* The command line interface's stop routine. This function is installed
4640 as a signal handler for SIGINT. The first time a user requests a
4641 stop, we call remote_stop to send a break or ^C. If there is no
4642 response from the target (it didn't stop when the user requested it),
4643 we ask the user if he'd like to detach from the target. */
4645 remote_interrupt (int signo)
4647 /* If this doesn't work, try more severe steps. */
4648 signal (signo, remote_interrupt_twice);
4650 gdb_call_async_signal_handler (sigint_remote_token, 1);
4653 /* The user typed ^C twice. */
4656 remote_interrupt_twice (int signo)
4658 signal (signo, ofunc);
4659 gdb_call_async_signal_handler (sigint_remote_twice_token, 1);
4660 signal (signo, remote_interrupt);
4663 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
4664 thread, all threads of a remote process, or all threads of all
4668 remote_stop_ns (ptid_t ptid)
4670 struct remote_state *rs = get_remote_state ();
4672 char *endp = rs->buf + get_remote_packet_size ();
4674 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
4675 remote_vcont_probe (rs);
4677 if (!rs->support_vCont_t)
4678 error (_("Remote server does not support stopping threads"));
4680 if (ptid_equal (ptid, minus_one_ptid)
4681 || (!remote_multi_process_p (rs) && ptid_is_pid (ptid)))
4682 p += xsnprintf (p, endp - p, "vCont;t");
4687 p += xsnprintf (p, endp - p, "vCont;t:");
4689 if (ptid_is_pid (ptid))
4690 /* All (-1) threads of process. */
4691 nptid = ptid_build (ptid_get_pid (ptid), 0, -1);
4694 /* Small optimization: if we already have a stop reply for
4695 this thread, no use in telling the stub we want this
4697 if (peek_stop_reply (ptid))
4703 p = write_ptid (p, endp, nptid);
4706 /* In non-stop, we get an immediate OK reply. The stop reply will
4707 come in asynchronously by notification. */
4709 getpkt (&rs->buf, &rs->buf_size, 0);
4710 if (strcmp (rs->buf, "OK") != 0)
4711 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf);
4714 /* All-stop version of target_stop. Sends a break or a ^C to stop the
4715 remote target. It is undefined which thread of which process
4716 reports the stop. */
4719 remote_stop_as (ptid_t ptid)
4721 struct remote_state *rs = get_remote_state ();
4723 rs->ctrlc_pending_p = 1;
4725 /* If the inferior is stopped already, but the core didn't know
4726 about it yet, just ignore the request. The cached wait status
4727 will be collected in remote_wait. */
4728 if (rs->cached_wait_status)
4731 /* Send interrupt_sequence to remote target. */
4732 send_interrupt_sequence ();
4735 /* This is the generic stop called via the target vector. When a target
4736 interrupt is requested, either by the command line or the GUI, we
4737 will eventually end up here. */
4740 remote_stop (ptid_t ptid)
4743 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
4746 remote_stop_ns (ptid);
4748 remote_stop_as (ptid);
4751 /* Ask the user what to do when an interrupt is received. */
4754 interrupt_query (void)
4756 target_terminal_ours ();
4758 if (target_can_async_p ())
4760 signal (SIGINT, handle_sigint);
4761 deprecated_throw_reason (RETURN_QUIT);
4765 if (query (_("Interrupted while waiting for the program.\n\
4766 Give up (and stop debugging it)? ")))
4769 deprecated_throw_reason (RETURN_QUIT);
4773 target_terminal_inferior ();
4776 /* Enable/disable target terminal ownership. Most targets can use
4777 terminal groups to control terminal ownership. Remote targets are
4778 different in that explicit transfer of ownership to/from GDB/target
4782 remote_terminal_inferior (void)
4784 if (!target_async_permitted)
4785 /* Nothing to do. */
4788 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
4789 idempotent. The event-loop GDB talking to an asynchronous target
4790 with a synchronous command calls this function from both
4791 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
4792 transfer the terminal to the target when it shouldn't this guard
4794 if (!remote_async_terminal_ours_p)
4796 delete_file_handler (input_fd);
4797 remote_async_terminal_ours_p = 0;
4798 initialize_sigint_signal_handler ();
4799 /* NOTE: At this point we could also register our selves as the
4800 recipient of all input. Any characters typed could then be
4801 passed on down to the target. */
4805 remote_terminal_ours (void)
4807 if (!target_async_permitted)
4808 /* Nothing to do. */
4811 /* See FIXME in remote_terminal_inferior. */
4812 if (remote_async_terminal_ours_p)
4814 cleanup_sigint_signal_handler (NULL);
4815 add_file_handler (input_fd, stdin_event_handler, 0);
4816 remote_async_terminal_ours_p = 1;
4820 remote_console_output (char *msg)
4824 for (p = msg; p[0] && p[1]; p += 2)
4827 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
4831 fputs_unfiltered (tb, gdb_stdtarg);
4833 gdb_flush (gdb_stdtarg);
4836 typedef struct cached_reg
4839 gdb_byte data[MAX_REGISTER_SIZE];
4842 DEF_VEC_O(cached_reg_t);
4846 struct stop_reply *next;
4850 struct target_waitstatus ws;
4852 VEC(cached_reg_t) *regcache;
4854 int stopped_by_watchpoint_p;
4855 CORE_ADDR watch_data_address;
4863 /* The list of already fetched and acknowledged stop events. */
4864 static struct stop_reply *stop_reply_queue;
4866 static struct stop_reply *
4867 stop_reply_xmalloc (void)
4869 struct stop_reply *r = XMALLOC (struct stop_reply);
4876 stop_reply_xfree (struct stop_reply *r)
4880 VEC_free (cached_reg_t, r->regcache);
4885 /* Discard all pending stop replies of inferior PID. If PID is -1,
4886 discard everything. */
4889 discard_pending_stop_replies (int pid)
4891 struct stop_reply *prev = NULL, *reply, *next;
4893 /* Discard the in-flight notification. */
4894 if (pending_stop_reply != NULL
4896 || ptid_get_pid (pending_stop_reply->ptid) == pid))
4898 stop_reply_xfree (pending_stop_reply);
4899 pending_stop_reply = NULL;
4902 /* Discard the stop replies we have already pulled with
4904 for (reply = stop_reply_queue; reply; reply = next)
4908 || ptid_get_pid (reply->ptid) == pid)
4910 if (reply == stop_reply_queue)
4911 stop_reply_queue = reply->next;
4913 prev->next = reply->next;
4915 stop_reply_xfree (reply);
4922 /* Cleanup wrapper. */
4925 do_stop_reply_xfree (void *arg)
4927 struct stop_reply *r = arg;
4929 stop_reply_xfree (r);
4932 /* Look for a queued stop reply belonging to PTID. If one is found,
4933 remove it from the queue, and return it. Returns NULL if none is
4934 found. If there are still queued events left to process, tell the
4935 event loop to get back to target_wait soon. */
4937 static struct stop_reply *
4938 queued_stop_reply (ptid_t ptid)
4940 struct stop_reply *it;
4941 struct stop_reply **it_link;
4943 it = stop_reply_queue;
4944 it_link = &stop_reply_queue;
4947 if (ptid_match (it->ptid, ptid))
4949 *it_link = it->next;
4954 it_link = &it->next;
4958 if (stop_reply_queue)
4959 /* There's still at least an event left. */
4960 mark_async_event_handler (remote_async_inferior_event_token);
4965 /* Push a fully parsed stop reply in the stop reply queue. Since we
4966 know that we now have at least one queued event left to pass to the
4967 core side, tell the event loop to get back to target_wait soon. */
4970 push_stop_reply (struct stop_reply *new_event)
4972 struct stop_reply *event;
4974 if (stop_reply_queue)
4976 for (event = stop_reply_queue;
4977 event && event->next;
4978 event = event->next)
4981 event->next = new_event;
4984 stop_reply_queue = new_event;
4986 mark_async_event_handler (remote_async_inferior_event_token);
4989 /* Returns true if we have a stop reply for PTID. */
4992 peek_stop_reply (ptid_t ptid)
4994 struct stop_reply *it;
4996 for (it = stop_reply_queue; it; it = it->next)
4997 if (ptid_equal (ptid, it->ptid))
4999 if (it->ws.kind == TARGET_WAITKIND_STOPPED)
5006 /* Parse the stop reply in BUF. Either the function succeeds, and the
5007 result is stored in EVENT, or throws an error. */
5010 remote_parse_stop_reply (char *buf, struct stop_reply *event)
5012 struct remote_arch_state *rsa = get_remote_arch_state ();
5016 event->ptid = null_ptid;
5017 event->ws.kind = TARGET_WAITKIND_IGNORE;
5018 event->ws.value.integer = 0;
5019 event->solibs_changed = 0;
5020 event->replay_event = 0;
5021 event->stopped_by_watchpoint_p = 0;
5022 event->regcache = NULL;
5027 case 'T': /* Status with PC, SP, FP, ... */
5028 /* Expedited reply, containing Signal, {regno, reg} repeat. */
5029 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
5031 n... = register number
5032 r... = register contents
5035 p = &buf[3]; /* after Txx */
5043 /* If the packet contains a register number, save it in
5044 pnum and set p1 to point to the character following it.
5045 Otherwise p1 points to p. */
5047 /* If this packet is an awatch packet, don't parse the 'a'
5048 as a register number. */
5050 if (strncmp (p, "awatch", strlen("awatch")) != 0
5051 && strncmp (p, "core", strlen ("core") != 0))
5053 /* Read the ``P'' register number. */
5054 pnum = strtol (p, &p_temp, 16);
5060 if (p1 == p) /* No register number present here. */
5062 p1 = strchr (p, ':');
5064 error (_("Malformed packet(a) (missing colon): %s\n\
5067 if (strncmp (p, "thread", p1 - p) == 0)
5068 event->ptid = read_ptid (++p1, &p);
5069 else if ((strncmp (p, "watch", p1 - p) == 0)
5070 || (strncmp (p, "rwatch", p1 - p) == 0)
5071 || (strncmp (p, "awatch", p1 - p) == 0))
5073 event->stopped_by_watchpoint_p = 1;
5074 p = unpack_varlen_hex (++p1, &addr);
5075 event->watch_data_address = (CORE_ADDR) addr;
5077 else if (strncmp (p, "library", p1 - p) == 0)
5081 while (*p_temp && *p_temp != ';')
5084 event->solibs_changed = 1;
5087 else if (strncmp (p, "replaylog", p1 - p) == 0)
5089 /* NO_HISTORY event.
5090 p1 will indicate "begin" or "end", but
5091 it makes no difference for now, so ignore it. */
5092 event->replay_event = 1;
5093 p_temp = strchr (p1 + 1, ';');
5097 else if (strncmp (p, "core", p1 - p) == 0)
5101 p = unpack_varlen_hex (++p1, &c);
5106 /* Silently skip unknown optional info. */
5107 p_temp = strchr (p1 + 1, ';');
5114 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
5115 cached_reg_t cached_reg;
5120 error (_("Malformed packet(b) (missing colon): %s\n\
5126 error (_("Remote sent bad register number %s: %s\n\
5128 hex_string (pnum), p, buf);
5130 cached_reg.num = reg->regnum;
5132 fieldsize = hex2bin (p, cached_reg.data,
5133 register_size (target_gdbarch,
5136 if (fieldsize < register_size (target_gdbarch,
5138 warning (_("Remote reply is too short: %s"), buf);
5140 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
5144 error (_("Remote register badly formatted: %s\nhere: %s"),
5149 case 'S': /* Old style status, just signal only. */
5150 if (event->solibs_changed)
5151 event->ws.kind = TARGET_WAITKIND_LOADED;
5152 else if (event->replay_event)
5153 event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
5156 event->ws.kind = TARGET_WAITKIND_STOPPED;
5157 event->ws.value.sig = (enum target_signal)
5158 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
5161 case 'W': /* Target exited. */
5168 /* GDB used to accept only 2 hex chars here. Stubs should
5169 only send more if they detect GDB supports multi-process
5171 p = unpack_varlen_hex (&buf[1], &value);
5175 /* The remote process exited. */
5176 event->ws.kind = TARGET_WAITKIND_EXITED;
5177 event->ws.value.integer = value;
5181 /* The remote process exited with a signal. */
5182 event->ws.kind = TARGET_WAITKIND_SIGNALLED;
5183 event->ws.value.sig = (enum target_signal) value;
5186 /* If no process is specified, assume inferior_ptid. */
5187 pid = ptid_get_pid (inferior_ptid);
5196 else if (strncmp (p,
5197 "process:", sizeof ("process:") - 1) == 0)
5201 p += sizeof ("process:") - 1;
5202 unpack_varlen_hex (p, &upid);
5206 error (_("unknown stop reply packet: %s"), buf);
5209 error (_("unknown stop reply packet: %s"), buf);
5210 event->ptid = pid_to_ptid (pid);
5215 if (non_stop && ptid_equal (event->ptid, null_ptid))
5216 error (_("No process or thread specified in stop reply: %s"), buf);
5219 /* When the stub wants to tell GDB about a new stop reply, it sends a
5220 stop notification (%Stop). Those can come it at any time, hence,
5221 we have to make sure that any pending putpkt/getpkt sequence we're
5222 making is finished, before querying the stub for more events with
5223 vStopped. E.g., if we started a vStopped sequence immediatelly
5224 upon receiving the %Stop notification, something like this could
5232 1.6) <-- (registers reply to step #1.3)
5234 Obviously, the reply in step #1.6 would be unexpected to a vStopped
5237 To solve this, whenever we parse a %Stop notification sucessfully,
5238 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
5239 doing whatever we were doing:
5245 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
5246 2.5) <-- (registers reply to step #2.3)
5248 Eventualy after step #2.5, we return to the event loop, which
5249 notices there's an event on the
5250 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
5251 associated callback --- the function below. At this point, we're
5252 always safe to start a vStopped sequence. :
5255 2.7) <-- T05 thread:2
5261 remote_get_pending_stop_replies (void)
5263 struct remote_state *rs = get_remote_state ();
5265 if (pending_stop_reply)
5268 putpkt ("vStopped");
5270 /* Now we can rely on it. */
5271 push_stop_reply (pending_stop_reply);
5272 pending_stop_reply = NULL;
5276 getpkt (&rs->buf, &rs->buf_size, 0);
5277 if (strcmp (rs->buf, "OK") == 0)
5281 struct cleanup *old_chain;
5282 struct stop_reply *stop_reply = stop_reply_xmalloc ();
5284 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply);
5285 remote_parse_stop_reply (rs->buf, stop_reply);
5288 putpkt ("vStopped");
5290 if (stop_reply->ws.kind != TARGET_WAITKIND_IGNORE)
5292 /* Now we can rely on it. */
5293 discard_cleanups (old_chain);
5294 push_stop_reply (stop_reply);
5297 /* We got an unknown stop reply. */
5298 do_cleanups (old_chain);
5305 /* Called when it is decided that STOP_REPLY holds the info of the
5306 event that is to be returned to the core. This function always
5307 destroys STOP_REPLY. */
5310 process_stop_reply (struct stop_reply *stop_reply,
5311 struct target_waitstatus *status)
5315 *status = stop_reply->ws;
5316 ptid = stop_reply->ptid;
5318 /* If no thread/process was reported by the stub, assume the current
5320 if (ptid_equal (ptid, null_ptid))
5321 ptid = inferior_ptid;
5323 if (status->kind != TARGET_WAITKIND_EXITED
5324 && status->kind != TARGET_WAITKIND_SIGNALLED)
5326 /* Expedited registers. */
5327 if (stop_reply->regcache)
5329 struct regcache *regcache
5330 = get_thread_arch_regcache (ptid, target_gdbarch);
5335 VEC_iterate(cached_reg_t, stop_reply->regcache, ix, reg);
5337 regcache_raw_supply (regcache, reg->num, reg->data);
5338 VEC_free (cached_reg_t, stop_reply->regcache);
5341 remote_stopped_by_watchpoint_p = stop_reply->stopped_by_watchpoint_p;
5342 remote_watch_data_address = stop_reply->watch_data_address;
5344 remote_notice_new_inferior (ptid, 0);
5345 demand_private_info (ptid)->core = stop_reply->core;
5348 stop_reply_xfree (stop_reply);
5352 /* The non-stop mode version of target_wait. */
5355 remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
5357 struct remote_state *rs = get_remote_state ();
5358 struct stop_reply *stop_reply;
5361 /* If in non-stop mode, get out of getpkt even if a
5362 notification is received. */
5364 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
5371 case 'E': /* Error of some sort. */
5372 /* We're out of sync with the target now. Did it continue
5373 or not? We can't tell which thread it was in non-stop,
5374 so just ignore this. */
5375 warning (_("Remote failure reply: %s"), rs->buf);
5377 case 'O': /* Console output. */
5378 remote_console_output (rs->buf + 1);
5381 warning (_("Invalid remote reply: %s"), rs->buf);
5385 /* Acknowledge a pending stop reply that may have arrived in the
5387 if (pending_stop_reply != NULL)
5388 remote_get_pending_stop_replies ();
5390 /* If indeed we noticed a stop reply, we're done. */
5391 stop_reply = queued_stop_reply (ptid);
5392 if (stop_reply != NULL)
5393 return process_stop_reply (stop_reply, status);
5395 /* Still no event. If we're just polling for an event, then
5396 return to the event loop. */
5397 if (options & TARGET_WNOHANG)
5399 status->kind = TARGET_WAITKIND_IGNORE;
5400 return minus_one_ptid;
5403 /* Otherwise do a blocking wait. */
5404 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
5409 /* Wait until the remote machine stops, then return, storing status in
5410 STATUS just as `wait' would. */
5413 remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options)
5415 struct remote_state *rs = get_remote_state ();
5416 ptid_t event_ptid = null_ptid;
5418 struct stop_reply *stop_reply;
5422 status->kind = TARGET_WAITKIND_IGNORE;
5423 status->value.integer = 0;
5425 stop_reply = queued_stop_reply (ptid);
5426 if (stop_reply != NULL)
5427 return process_stop_reply (stop_reply, status);
5429 if (rs->cached_wait_status)
5430 /* Use the cached wait status, but only once. */
5431 rs->cached_wait_status = 0;
5436 if (!target_is_async_p ())
5438 ofunc = signal (SIGINT, remote_interrupt);
5439 /* If the user hit C-c before this packet, or between packets,
5440 pretend that it was hit right here. */
5444 remote_interrupt (SIGINT);
5448 /* FIXME: cagney/1999-09-27: If we're in async mode we should
5449 _never_ wait for ever -> test on target_is_async_p().
5450 However, before we do that we need to ensure that the caller
5451 knows how to take the target into/out of async mode. */
5452 ret = getpkt_sane (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
5453 if (!target_is_async_p ())
5454 signal (SIGINT, ofunc);
5459 remote_stopped_by_watchpoint_p = 0;
5461 /* We got something. */
5462 rs->waiting_for_stop_reply = 0;
5464 /* Assume that the target has acknowledged Ctrl-C unless we receive
5465 an 'F' or 'O' packet. */
5466 if (buf[0] != 'F' && buf[0] != 'O')
5467 rs->ctrlc_pending_p = 0;
5471 case 'E': /* Error of some sort. */
5472 /* We're out of sync with the target now. Did it continue or
5473 not? Not is more likely, so report a stop. */
5474 warning (_("Remote failure reply: %s"), buf);
5475 status->kind = TARGET_WAITKIND_STOPPED;
5476 status->value.sig = TARGET_SIGNAL_0;
5478 case 'F': /* File-I/O request. */
5479 remote_fileio_request (buf, rs->ctrlc_pending_p);
5480 rs->ctrlc_pending_p = 0;
5482 case 'T': case 'S': case 'X': case 'W':
5484 struct stop_reply *stop_reply;
5485 struct cleanup *old_chain;
5487 stop_reply = stop_reply_xmalloc ();
5488 old_chain = make_cleanup (do_stop_reply_xfree, stop_reply);
5489 remote_parse_stop_reply (buf, stop_reply);
5490 discard_cleanups (old_chain);
5491 event_ptid = process_stop_reply (stop_reply, status);
5494 case 'O': /* Console output. */
5495 remote_console_output (buf + 1);
5497 /* The target didn't really stop; keep waiting. */
5498 rs->waiting_for_stop_reply = 1;
5502 if (last_sent_signal != TARGET_SIGNAL_0)
5504 /* Zero length reply means that we tried 'S' or 'C' and the
5505 remote system doesn't support it. */
5506 target_terminal_ours_for_output ();
5508 ("Can't send signals to this remote system. %s not sent.\n",
5509 target_signal_to_name (last_sent_signal));
5510 last_sent_signal = TARGET_SIGNAL_0;
5511 target_terminal_inferior ();
5513 strcpy ((char *) buf, last_sent_step ? "s" : "c");
5514 putpkt ((char *) buf);
5516 /* We just told the target to resume, so a stop reply is in
5518 rs->waiting_for_stop_reply = 1;
5521 /* else fallthrough */
5523 warning (_("Invalid remote reply: %s"), buf);
5525 rs->waiting_for_stop_reply = 1;
5529 if (status->kind == TARGET_WAITKIND_IGNORE)
5531 /* Nothing interesting happened. If we're doing a non-blocking
5532 poll, we're done. Otherwise, go back to waiting. */
5533 if (options & TARGET_WNOHANG)
5534 return minus_one_ptid;
5538 else if (status->kind != TARGET_WAITKIND_EXITED
5539 && status->kind != TARGET_WAITKIND_SIGNALLED)
5541 if (!ptid_equal (event_ptid, null_ptid))
5542 record_currthread (event_ptid);
5544 event_ptid = inferior_ptid;
5547 /* A process exit. Invalidate our notion of current thread. */
5548 record_currthread (minus_one_ptid);
5553 /* Wait until the remote machine stops, then return, storing status in
5554 STATUS just as `wait' would. */
5557 remote_wait (struct target_ops *ops,
5558 ptid_t ptid, struct target_waitstatus *status, int options)
5563 event_ptid = remote_wait_ns (ptid, status, options);
5565 event_ptid = remote_wait_as (ptid, status, options);
5567 if (target_can_async_p ())
5569 /* If there are are events left in the queue tell the event loop
5571 if (stop_reply_queue)
5572 mark_async_event_handler (remote_async_inferior_event_token);
5578 /* Fetch a single register using a 'p' packet. */
5581 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
5583 struct remote_state *rs = get_remote_state ();
5585 char regp[MAX_REGISTER_SIZE];
5588 if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE)
5591 if (reg->pnum == -1)
5596 p += hexnumstr (p, reg->pnum);
5599 getpkt (&rs->buf, &rs->buf_size, 0);
5603 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
5607 case PACKET_UNKNOWN:
5610 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
5611 gdbarch_register_name (get_regcache_arch (regcache),
5616 /* If this register is unfetchable, tell the regcache. */
5619 regcache_raw_supply (regcache, reg->regnum, NULL);
5623 /* Otherwise, parse and supply the value. */
5629 error (_("fetch_register_using_p: early buf termination"));
5631 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
5634 regcache_raw_supply (regcache, reg->regnum, regp);
5638 /* Fetch the registers included in the target's 'g' packet. */
5641 send_g_packet (void)
5643 struct remote_state *rs = get_remote_state ();
5646 sprintf (rs->buf, "g");
5647 remote_send (&rs->buf, &rs->buf_size);
5649 /* We can get out of synch in various cases. If the first character
5650 in the buffer is not a hex character, assume that has happened
5651 and try to fetch another packet to read. */
5652 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
5653 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
5654 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
5655 && rs->buf[0] != 'x') /* New: unavailable register value. */
5658 fprintf_unfiltered (gdb_stdlog,
5659 "Bad register packet; fetching a new packet\n");
5660 getpkt (&rs->buf, &rs->buf_size, 0);
5663 buf_len = strlen (rs->buf);
5665 /* Sanity check the received packet. */
5666 if (buf_len % 2 != 0)
5667 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
5673 process_g_packet (struct regcache *regcache)
5675 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5676 struct remote_state *rs = get_remote_state ();
5677 struct remote_arch_state *rsa = get_remote_arch_state ();
5682 buf_len = strlen (rs->buf);
5684 /* Further sanity checks, with knowledge of the architecture. */
5685 if (buf_len > 2 * rsa->sizeof_g_packet)
5686 error (_("Remote 'g' packet reply is too long: %s"), rs->buf);
5688 /* Save the size of the packet sent to us by the target. It is used
5689 as a heuristic when determining the max size of packets that the
5690 target can safely receive. */
5691 if (rsa->actual_register_packet_size == 0)
5692 rsa->actual_register_packet_size = buf_len;
5694 /* If this is smaller than we guessed the 'g' packet would be,
5695 update our records. A 'g' reply that doesn't include a register's
5696 value implies either that the register is not available, or that
5697 the 'p' packet must be used. */
5698 if (buf_len < 2 * rsa->sizeof_g_packet)
5700 rsa->sizeof_g_packet = buf_len / 2;
5702 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
5704 if (rsa->regs[i].pnum == -1)
5707 if (rsa->regs[i].offset >= rsa->sizeof_g_packet)
5708 rsa->regs[i].in_g_packet = 0;
5710 rsa->regs[i].in_g_packet = 1;
5714 regs = alloca (rsa->sizeof_g_packet);
5716 /* Unimplemented registers read as all bits zero. */
5717 memset (regs, 0, rsa->sizeof_g_packet);
5719 /* Reply describes registers byte by byte, each byte encoded as two
5720 hex characters. Suck them all up, then supply them to the
5721 register cacheing/storage mechanism. */
5724 for (i = 0; i < rsa->sizeof_g_packet; i++)
5726 if (p[0] == 0 || p[1] == 0)
5727 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
5728 internal_error (__FILE__, __LINE__,
5729 _("unexpected end of 'g' packet reply"));
5731 if (p[0] == 'x' && p[1] == 'x')
5732 regs[i] = 0; /* 'x' */
5734 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
5738 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
5740 struct packet_reg *r = &rsa->regs[i];
5744 if (r->offset * 2 >= strlen (rs->buf))
5745 /* This shouldn't happen - we adjusted in_g_packet above. */
5746 internal_error (__FILE__, __LINE__,
5747 _("unexpected end of 'g' packet reply"));
5748 else if (rs->buf[r->offset * 2] == 'x')
5750 gdb_assert (r->offset * 2 < strlen (rs->buf));
5751 /* The register isn't available, mark it as such (at
5752 the same time setting the value to zero). */
5753 regcache_raw_supply (regcache, r->regnum, NULL);
5756 regcache_raw_supply (regcache, r->regnum,
5763 fetch_registers_using_g (struct regcache *regcache)
5766 process_g_packet (regcache);
5770 remote_fetch_registers (struct target_ops *ops,
5771 struct regcache *regcache, int regnum)
5773 struct remote_arch_state *rsa = get_remote_arch_state ();
5776 set_general_thread (inferior_ptid);
5780 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
5782 gdb_assert (reg != NULL);
5784 /* If this register might be in the 'g' packet, try that first -
5785 we are likely to read more than one register. If this is the
5786 first 'g' packet, we might be overly optimistic about its
5787 contents, so fall back to 'p'. */
5788 if (reg->in_g_packet)
5790 fetch_registers_using_g (regcache);
5791 if (reg->in_g_packet)
5795 if (fetch_register_using_p (regcache, reg))
5798 /* This register is not available. */
5799 regcache_raw_supply (regcache, reg->regnum, NULL);
5804 fetch_registers_using_g (regcache);
5806 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
5807 if (!rsa->regs[i].in_g_packet)
5808 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
5810 /* This register is not available. */
5811 regcache_raw_supply (regcache, i, NULL);
5815 /* Prepare to store registers. Since we may send them all (using a
5816 'G' request), we have to read out the ones we don't want to change
5820 remote_prepare_to_store (struct regcache *regcache)
5822 struct remote_arch_state *rsa = get_remote_arch_state ();
5824 gdb_byte buf[MAX_REGISTER_SIZE];
5826 /* Make sure the entire registers array is valid. */
5827 switch (remote_protocol_packets[PACKET_P].support)
5829 case PACKET_DISABLE:
5830 case PACKET_SUPPORT_UNKNOWN:
5831 /* Make sure all the necessary registers are cached. */
5832 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
5833 if (rsa->regs[i].in_g_packet)
5834 regcache_raw_read (regcache, rsa->regs[i].regnum, buf);
5841 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
5842 packet was not recognized. */
5845 store_register_using_P (const struct regcache *regcache,
5846 struct packet_reg *reg)
5848 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5849 struct remote_state *rs = get_remote_state ();
5850 /* Try storing a single register. */
5851 char *buf = rs->buf;
5852 gdb_byte regp[MAX_REGISTER_SIZE];
5855 if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE)
5858 if (reg->pnum == -1)
5861 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
5862 p = buf + strlen (buf);
5863 regcache_raw_collect (regcache, reg->regnum, regp);
5864 bin2hex (regp, p, register_size (gdbarch, reg->regnum));
5866 getpkt (&rs->buf, &rs->buf_size, 0);
5868 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
5873 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
5874 gdbarch_register_name (gdbarch, reg->regnum), rs->buf);
5875 case PACKET_UNKNOWN:
5878 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
5882 /* Store register REGNUM, or all registers if REGNUM == -1, from the
5883 contents of the register cache buffer. FIXME: ignores errors. */
5886 store_registers_using_G (const struct regcache *regcache)
5888 struct remote_state *rs = get_remote_state ();
5889 struct remote_arch_state *rsa = get_remote_arch_state ();
5893 /* Extract all the registers in the regcache copying them into a
5898 regs = alloca (rsa->sizeof_g_packet);
5899 memset (regs, 0, rsa->sizeof_g_packet);
5900 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
5902 struct packet_reg *r = &rsa->regs[i];
5905 regcache_raw_collect (regcache, r->regnum, regs + r->offset);
5909 /* Command describes registers byte by byte,
5910 each byte encoded as two hex characters. */
5913 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
5915 bin2hex (regs, p, rsa->sizeof_g_packet);
5917 getpkt (&rs->buf, &rs->buf_size, 0);
5918 if (packet_check_result (rs->buf) == PACKET_ERROR)
5919 error (_("Could not write registers; remote failure reply '%s'"),
5923 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
5924 of the register cache buffer. FIXME: ignores errors. */
5927 remote_store_registers (struct target_ops *ops,
5928 struct regcache *regcache, int regnum)
5930 struct remote_arch_state *rsa = get_remote_arch_state ();
5933 set_general_thread (inferior_ptid);
5937 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
5939 gdb_assert (reg != NULL);
5941 /* Always prefer to store registers using the 'P' packet if
5942 possible; we often change only a small number of registers.
5943 Sometimes we change a larger number; we'd need help from a
5944 higher layer to know to use 'G'. */
5945 if (store_register_using_P (regcache, reg))
5948 /* For now, don't complain if we have no way to write the
5949 register. GDB loses track of unavailable registers too
5950 easily. Some day, this may be an error. We don't have
5951 any way to read the register, either... */
5952 if (!reg->in_g_packet)
5955 store_registers_using_G (regcache);
5959 store_registers_using_G (regcache);
5961 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
5962 if (!rsa->regs[i].in_g_packet)
5963 if (!store_register_using_P (regcache, &rsa->regs[i]))
5964 /* See above for why we do not issue an error here. */
5969 /* Return the number of hex digits in num. */
5972 hexnumlen (ULONGEST num)
5976 for (i = 0; num != 0; i++)
5982 /* Set BUF to the minimum number of hex digits representing NUM. */
5985 hexnumstr (char *buf, ULONGEST num)
5987 int len = hexnumlen (num);
5989 return hexnumnstr (buf, num, len);
5993 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
5996 hexnumnstr (char *buf, ULONGEST num, int width)
6002 for (i = width - 1; i >= 0; i--)
6004 buf[i] = "0123456789abcdef"[(num & 0xf)];
6011 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
6014 remote_address_masked (CORE_ADDR addr)
6016 int address_size = remote_address_size;
6018 /* If "remoteaddresssize" was not set, default to target address size. */
6020 address_size = gdbarch_addr_bit (target_gdbarch);
6022 if (address_size > 0
6023 && address_size < (sizeof (ULONGEST) * 8))
6025 /* Only create a mask when that mask can safely be constructed
6026 in a ULONGEST variable. */
6029 mask = (mask << address_size) - 1;
6035 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
6036 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
6037 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
6038 (which may be more than *OUT_LEN due to escape characters). The
6039 total number of bytes in the output buffer will be at most
6043 remote_escape_output (const gdb_byte *buffer, int len,
6044 gdb_byte *out_buf, int *out_len,
6047 int input_index, output_index;
6050 for (input_index = 0; input_index < len; input_index++)
6052 gdb_byte b = buffer[input_index];
6054 if (b == '$' || b == '#' || b == '}')
6056 /* These must be escaped. */
6057 if (output_index + 2 > out_maxlen)
6059 out_buf[output_index++] = '}';
6060 out_buf[output_index++] = b ^ 0x20;
6064 if (output_index + 1 > out_maxlen)
6066 out_buf[output_index++] = b;
6070 *out_len = input_index;
6071 return output_index;
6074 /* Convert BUFFER, escaped data LEN bytes long, into binary data
6075 in OUT_BUF. Return the number of bytes written to OUT_BUF.
6076 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
6078 This function reverses remote_escape_output. It allows more
6079 escaped characters than that function does, in particular because
6080 '*' must be escaped to avoid the run-length encoding processing
6081 in reading packets. */
6084 remote_unescape_input (const gdb_byte *buffer, int len,
6085 gdb_byte *out_buf, int out_maxlen)
6087 int input_index, output_index;
6092 for (input_index = 0; input_index < len; input_index++)
6094 gdb_byte b = buffer[input_index];
6096 if (output_index + 1 > out_maxlen)
6098 warning (_("Received too much data from remote target;"
6099 " ignoring overflow."));
6100 return output_index;
6105 out_buf[output_index++] = b ^ 0x20;
6111 out_buf[output_index++] = b;
6115 error (_("Unmatched escape character in target response."));
6117 return output_index;
6120 /* Determine whether the remote target supports binary downloading.
6121 This is accomplished by sending a no-op memory write of zero length
6122 to the target at the specified address. It does not suffice to send
6123 the whole packet, since many stubs strip the eighth bit and
6124 subsequently compute a wrong checksum, which causes real havoc with
6127 NOTE: This can still lose if the serial line is not eight-bit
6128 clean. In cases like this, the user should clear "remote
6132 check_binary_download (CORE_ADDR addr)
6134 struct remote_state *rs = get_remote_state ();
6136 switch (remote_protocol_packets[PACKET_X].support)
6138 case PACKET_DISABLE:
6142 case PACKET_SUPPORT_UNKNOWN:
6148 p += hexnumstr (p, (ULONGEST) addr);
6150 p += hexnumstr (p, (ULONGEST) 0);
6154 putpkt_binary (rs->buf, (int) (p - rs->buf));
6155 getpkt (&rs->buf, &rs->buf_size, 0);
6157 if (rs->buf[0] == '\0')
6160 fprintf_unfiltered (gdb_stdlog,
6161 "binary downloading NOT "
6162 "supported by target\n");
6163 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
6168 fprintf_unfiltered (gdb_stdlog,
6169 "binary downloading suppported by target\n");
6170 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
6177 /* Write memory data directly to the remote machine.
6178 This does not inform the data cache; the data cache uses this.
6179 HEADER is the starting part of the packet.
6180 MEMADDR is the address in the remote memory space.
6181 MYADDR is the address of the buffer in our space.
6182 LEN is the number of bytes.
6183 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
6184 should send data as binary ('X'), or hex-encoded ('M').
6186 The function creates packet of the form
6187 <HEADER><ADDRESS>,<LENGTH>:<DATA>
6189 where encoding of <DATA> is termined by PACKET_FORMAT.
6191 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
6194 Returns the number of bytes transferred, or 0 (setting errno) for
6195 error. Only transfer a single packet. */
6198 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
6199 const gdb_byte *myaddr, int len,
6200 char packet_format, int use_length)
6202 struct remote_state *rs = get_remote_state ();
6212 if (packet_format != 'X' && packet_format != 'M')
6213 internal_error (__FILE__, __LINE__,
6214 _("remote_write_bytes_aux: bad packet format"));
6219 payload_size = get_memory_write_packet_size ();
6221 /* The packet buffer will be large enough for the payload;
6222 get_memory_packet_size ensures this. */
6225 /* Compute the size of the actual payload by subtracting out the
6226 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
6228 payload_size -= strlen ("$,:#NN");
6230 /* The comma won't be used. */
6232 header_length = strlen (header);
6233 payload_size -= header_length;
6234 payload_size -= hexnumlen (memaddr);
6236 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
6238 strcat (rs->buf, header);
6239 p = rs->buf + strlen (header);
6241 /* Compute a best guess of the number of bytes actually transfered. */
6242 if (packet_format == 'X')
6244 /* Best guess at number of bytes that will fit. */
6245 todo = min (len, payload_size);
6247 payload_size -= hexnumlen (todo);
6248 todo = min (todo, payload_size);
6252 /* Num bytes that will fit. */
6253 todo = min (len, payload_size / 2);
6255 payload_size -= hexnumlen (todo);
6256 todo = min (todo, payload_size / 2);
6260 internal_error (__FILE__, __LINE__,
6261 _("minumum packet size too small to write data"));
6263 /* If we already need another packet, then try to align the end
6264 of this packet to a useful boundary. */
6265 if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len)
6266 todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
6268 /* Append "<memaddr>". */
6269 memaddr = remote_address_masked (memaddr);
6270 p += hexnumstr (p, (ULONGEST) memaddr);
6277 /* Append <len>. Retain the location/size of <len>. It may need to
6278 be adjusted once the packet body has been created. */
6280 plenlen = hexnumstr (p, (ULONGEST) todo);
6288 /* Append the packet body. */
6289 if (packet_format == 'X')
6291 /* Binary mode. Send target system values byte by byte, in
6292 increasing byte addresses. Only escape certain critical
6294 payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes,
6297 /* If not all TODO bytes fit, then we'll need another packet. Make
6298 a second try to keep the end of the packet aligned. Don't do
6299 this if the packet is tiny. */
6300 if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
6304 new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1))
6306 if (new_nr_bytes != nr_bytes)
6307 payload_length = remote_escape_output (myaddr, new_nr_bytes,
6312 p += payload_length;
6313 if (use_length && nr_bytes < todo)
6315 /* Escape chars have filled up the buffer prematurely,
6316 and we have actually sent fewer bytes than planned.
6317 Fix-up the length field of the packet. Use the same
6318 number of characters as before. */
6319 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
6320 *plen = ':'; /* overwrite \0 from hexnumnstr() */
6325 /* Normal mode: Send target system values byte by byte, in
6326 increasing byte addresses. Each byte is encoded as a two hex
6328 nr_bytes = bin2hex (myaddr, p, todo);
6332 putpkt_binary (rs->buf, (int) (p - rs->buf));
6333 getpkt (&rs->buf, &rs->buf_size, 0);
6335 if (rs->buf[0] == 'E')
6337 /* There is no correspondance between what the remote protocol
6338 uses for errors and errno codes. We would like a cleaner way
6339 of representing errors (big enough to include errno codes,
6340 bfd_error codes, and others). But for now just return EIO. */
6345 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
6346 fewer bytes than we'd planned. */
6350 /* Write memory data directly to the remote machine.
6351 This does not inform the data cache; the data cache uses this.
6352 MEMADDR is the address in the remote memory space.
6353 MYADDR is the address of the buffer in our space.
6354 LEN is the number of bytes.
6356 Returns number of bytes transferred, or 0 (setting errno) for
6357 error. Only transfer a single packet. */
6360 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
6362 char *packet_format = 0;
6364 /* Check whether the target supports binary download. */
6365 check_binary_download (memaddr);
6367 switch (remote_protocol_packets[PACKET_X].support)
6370 packet_format = "X";
6372 case PACKET_DISABLE:
6373 packet_format = "M";
6375 case PACKET_SUPPORT_UNKNOWN:
6376 internal_error (__FILE__, __LINE__,
6377 _("remote_write_bytes: bad internal state"));
6379 internal_error (__FILE__, __LINE__, _("bad switch"));
6382 return remote_write_bytes_aux (packet_format,
6383 memaddr, myaddr, len, packet_format[0], 1);
6386 /* Read memory data directly from the remote machine.
6387 This does not use the data cache; the data cache uses this.
6388 MEMADDR is the address in the remote memory space.
6389 MYADDR is the address of the buffer in our space.
6390 LEN is the number of bytes.
6392 Returns number of bytes transferred, or 0 for error. */
6394 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
6395 remote targets) shouldn't attempt to read the entire buffer.
6396 Instead it should read a single packet worth of data and then
6397 return the byte size of that packet to the caller. The caller (its
6398 caller and its callers caller ;-) already contains code for
6399 handling partial reads. */
6402 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
6404 struct remote_state *rs = get_remote_state ();
6405 int max_buf_size; /* Max size of packet output buffer. */
6411 max_buf_size = get_memory_read_packet_size ();
6412 /* The packet buffer will be large enough for the payload;
6413 get_memory_packet_size ensures this. */
6422 todo = min (len, max_buf_size / 2); /* num bytes that will fit. */
6424 /* construct "m"<memaddr>","<len>" */
6425 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
6426 memaddr = remote_address_masked (memaddr);
6429 p += hexnumstr (p, (ULONGEST) memaddr);
6431 p += hexnumstr (p, (ULONGEST) todo);
6435 getpkt (&rs->buf, &rs->buf_size, 0);
6437 if (rs->buf[0] == 'E'
6438 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
6439 && rs->buf[3] == '\0')
6441 /* There is no correspondance between what the remote
6442 protocol uses for errors and errno codes. We would like
6443 a cleaner way of representing errors (big enough to
6444 include errno codes, bfd_error codes, and others). But
6445 for now just return EIO. */
6450 /* Reply describes memory byte by byte,
6451 each byte encoded as two hex characters. */
6454 if ((i = hex2bin (p, myaddr, todo)) < todo)
6456 /* Reply is short. This means that we were able to read
6457 only part of what we wanted to. */
6458 return i + (origlen - len);
6468 /* Remote notification handler. */
6471 handle_notification (char *buf, size_t length)
6473 if (strncmp (buf, "Stop:", 5) == 0)
6475 if (pending_stop_reply)
6477 /* We've already parsed the in-flight stop-reply, but the
6478 stub for some reason thought we didn't, possibly due to
6479 timeout on its side. Just ignore it. */
6481 fprintf_unfiltered (gdb_stdlog, "ignoring resent notification\n");
6485 struct cleanup *old_chain;
6486 struct stop_reply *reply = stop_reply_xmalloc ();
6488 old_chain = make_cleanup (do_stop_reply_xfree, reply);
6490 remote_parse_stop_reply (buf + 5, reply);
6492 discard_cleanups (old_chain);
6494 /* Be careful to only set it after parsing, since an error
6495 may be thrown then. */
6496 pending_stop_reply = reply;
6498 /* Notify the event loop there's a stop reply to acknowledge
6499 and that there may be more events to fetch. */
6500 mark_async_event_handler (remote_async_get_pending_events_token);
6503 fprintf_unfiltered (gdb_stdlog, "stop notification captured\n");
6507 /* We ignore notifications we don't recognize, for compatibility
6508 with newer stubs. */
6513 /* Read or write LEN bytes from inferior memory at MEMADDR,
6514 transferring to or from debugger address BUFFER. Write to inferior
6515 if SHOULD_WRITE is nonzero. Returns length of data written or
6516 read; 0 for error. TARGET is unused. */
6519 remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
6520 int should_write, struct mem_attrib *attrib,
6521 struct target_ops *target)
6525 set_general_thread (inferior_ptid);
6528 res = remote_write_bytes (mem_addr, buffer, mem_len);
6530 res = remote_read_bytes (mem_addr, buffer, mem_len);
6535 /* Sends a packet with content determined by the printf format string
6536 FORMAT and the remaining arguments, then gets the reply. Returns
6537 whether the packet was a success, a failure, or unknown. */
6539 static enum packet_result
6540 remote_send_printf (const char *format, ...)
6542 struct remote_state *rs = get_remote_state ();
6543 int max_size = get_remote_packet_size ();
6546 va_start (ap, format);
6549 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
6550 internal_error (__FILE__, __LINE__, _("Too long remote packet."));
6552 if (putpkt (rs->buf) < 0)
6553 error (_("Communication problem with target."));
6556 getpkt (&rs->buf, &rs->buf_size, 0);
6558 return packet_check_result (rs->buf);
6562 restore_remote_timeout (void *p)
6564 int value = *(int *)p;
6566 remote_timeout = value;
6569 /* Flash writing can take quite some time. We'll set
6570 effectively infinite timeout for flash operations.
6571 In future, we'll need to decide on a better approach. */
6572 static const int remote_flash_timeout = 1000;
6575 remote_flash_erase (struct target_ops *ops,
6576 ULONGEST address, LONGEST length)
6578 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
6579 int saved_remote_timeout = remote_timeout;
6580 enum packet_result ret;
6581 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
6582 &saved_remote_timeout);
6584 remote_timeout = remote_flash_timeout;
6586 ret = remote_send_printf ("vFlashErase:%s,%s",
6587 phex (address, addr_size),
6591 case PACKET_UNKNOWN:
6592 error (_("Remote target does not support flash erase"));
6594 error (_("Error erasing flash with vFlashErase packet"));
6599 do_cleanups (back_to);
6603 remote_flash_write (struct target_ops *ops,
6604 ULONGEST address, LONGEST length,
6605 const gdb_byte *data)
6607 int saved_remote_timeout = remote_timeout;
6609 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
6610 &saved_remote_timeout);
6612 remote_timeout = remote_flash_timeout;
6613 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
6614 do_cleanups (back_to);
6620 remote_flash_done (struct target_ops *ops)
6622 int saved_remote_timeout = remote_timeout;
6624 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
6625 &saved_remote_timeout);
6627 remote_timeout = remote_flash_timeout;
6628 ret = remote_send_printf ("vFlashDone");
6629 do_cleanups (back_to);
6633 case PACKET_UNKNOWN:
6634 error (_("Remote target does not support vFlashDone"));
6636 error (_("Error finishing flash operation"));
6643 remote_files_info (struct target_ops *ignore)
6645 puts_filtered ("Debugging a target over a serial line.\n");
6648 /* Stuff for dealing with the packets which are part of this protocol.
6649 See comment at top of file for details. */
6651 /* Read a single character from the remote end. */
6654 readchar (int timeout)
6658 ch = serial_readchar (remote_desc, timeout);
6663 switch ((enum serial_rc) ch)
6667 error (_("Remote connection closed"));
6671 perror_with_name (_("Remote communication error. "
6672 "Target disconnected."));
6674 case SERIAL_TIMEOUT:
6680 /* Send the command in *BUF to the remote machine, and read the reply
6681 into *BUF. Report an error if we get an error reply. Resize
6682 *BUF using xrealloc if necessary to hold the result, and update
6686 remote_send (char **buf,
6690 getpkt (buf, sizeof_buf, 0);
6692 if ((*buf)[0] == 'E')
6693 error (_("Remote failure reply: %s"), *buf);
6696 /* Return a pointer to an xmalloc'ed string representing an escaped
6697 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t,
6698 etc. The caller is responsible for releasing the returned
6702 escape_buffer (const char *buf, int n)
6704 struct cleanup *old_chain;
6705 struct ui_file *stb;
6708 stb = mem_fileopen ();
6709 old_chain = make_cleanup_ui_file_delete (stb);
6711 fputstrn_unfiltered (buf, n, 0, stb);
6712 str = ui_file_xstrdup (stb, NULL);
6713 do_cleanups (old_chain);
6717 /* Display a null-terminated packet on stdout, for debugging, using C
6721 print_packet (char *buf)
6723 puts_filtered ("\"");
6724 fputstr_filtered (buf, '"', gdb_stdout);
6725 puts_filtered ("\"");
6731 return putpkt_binary (buf, strlen (buf));
6734 /* Send a packet to the remote machine, with error checking. The data
6735 of the packet is in BUF. The string in BUF can be at most
6736 get_remote_packet_size () - 5 to account for the $, # and checksum,
6737 and for a possible /0 if we are debugging (remote_debug) and want
6738 to print the sent packet as a string. */
6741 putpkt_binary (char *buf, int cnt)
6743 struct remote_state *rs = get_remote_state ();
6745 unsigned char csum = 0;
6746 char *buf2 = alloca (cnt + 6);
6752 /* Catch cases like trying to read memory or listing threads while
6753 we're waiting for a stop reply. The remote server wouldn't be
6754 ready to handle this request, so we'd hang and timeout. We don't
6755 have to worry about this in synchronous mode, because in that
6756 case it's not possible to issue a command while the target is
6757 running. This is not a problem in non-stop mode, because in that
6758 case, the stub is always ready to process serial input. */
6759 if (!non_stop && target_can_async_p () && rs->waiting_for_stop_reply)
6760 error (_("Cannot execute this command while the target is running."));
6762 /* We're sending out a new packet. Make sure we don't look at a
6763 stale cached response. */
6764 rs->cached_wait_status = 0;
6766 /* Copy the packet into buffer BUF2, encapsulating it
6767 and giving it a checksum. */
6772 for (i = 0; i < cnt; i++)
6778 *p++ = tohex ((csum >> 4) & 0xf);
6779 *p++ = tohex (csum & 0xf);
6781 /* Send it over and over until we get a positive ack. */
6785 int started_error_output = 0;
6789 struct cleanup *old_chain;
6793 str = escape_buffer (buf2, p - buf2);
6794 old_chain = make_cleanup (xfree, str);
6795 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s...", str);
6796 gdb_flush (gdb_stdlog);
6797 do_cleanups (old_chain);
6799 if (serial_write (remote_desc, buf2, p - buf2))
6800 perror_with_name (_("putpkt: write failed"));
6802 /* If this is a no acks version of the remote protocol, send the
6803 packet and move on. */
6807 /* Read until either a timeout occurs (-2) or '+' is read.
6808 Handle any notification that arrives in the mean time. */
6811 ch = readchar (remote_timeout);
6819 case SERIAL_TIMEOUT:
6822 if (started_error_output)
6824 putchar_unfiltered ('\n');
6825 started_error_output = 0;
6834 fprintf_unfiltered (gdb_stdlog, "Ack\n");
6838 fprintf_unfiltered (gdb_stdlog, "Nak\n");
6839 case SERIAL_TIMEOUT:
6843 break; /* Retransmit buffer. */
6847 fprintf_unfiltered (gdb_stdlog,
6848 "Packet instead of Ack, ignoring it\n");
6849 /* It's probably an old response sent because an ACK
6850 was lost. Gobble up the packet and ack it so it
6851 doesn't get retransmitted when we resend this
6854 serial_write (remote_desc, "+", 1);
6855 continue; /* Now, go look for +. */
6862 /* If we got a notification, handle it, and go back to looking
6864 /* We've found the start of a notification. Now
6865 collect the data. */
6866 val = read_frame (&rs->buf, &rs->buf_size);
6871 struct cleanup *old_chain;
6874 str = escape_buffer (rs->buf, val);
6875 old_chain = make_cleanup (xfree, str);
6876 fprintf_unfiltered (gdb_stdlog,
6877 " Notification received: %s\n",
6879 do_cleanups (old_chain);
6881 handle_notification (rs->buf, val);
6882 /* We're in sync now, rewait for the ack. */
6889 if (!started_error_output)
6891 started_error_output = 1;
6892 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
6894 fputc_unfiltered (ch & 0177, gdb_stdlog);
6895 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf);
6904 if (!started_error_output)
6906 started_error_output = 1;
6907 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
6909 fputc_unfiltered (ch & 0177, gdb_stdlog);
6913 break; /* Here to retransmit. */
6917 /* This is wrong. If doing a long backtrace, the user should be
6918 able to get out next time we call QUIT, without anything as
6919 violent as interrupt_query. If we want to provide a way out of
6920 here without getting to the next QUIT, it should be based on
6921 hitting ^C twice as in remote_wait. */
6932 /* Come here after finding the start of a frame when we expected an
6933 ack. Do our best to discard the rest of this packet. */
6942 c = readchar (remote_timeout);
6945 case SERIAL_TIMEOUT:
6946 /* Nothing we can do. */
6949 /* Discard the two bytes of checksum and stop. */
6950 c = readchar (remote_timeout);
6952 c = readchar (remote_timeout);
6955 case '*': /* Run length encoding. */
6956 /* Discard the repeat count. */
6957 c = readchar (remote_timeout);
6962 /* A regular character. */
6968 /* Come here after finding the start of the frame. Collect the rest
6969 into *BUF, verifying the checksum, length, and handling run-length
6970 compression. NUL terminate the buffer. If there is not enough room,
6971 expand *BUF using xrealloc.
6973 Returns -1 on error, number of characters in buffer (ignoring the
6974 trailing NULL) on success. (could be extended to return one of the
6975 SERIAL status indications). */
6978 read_frame (char **buf_p,
6985 struct remote_state *rs = get_remote_state ();
6992 c = readchar (remote_timeout);
6995 case SERIAL_TIMEOUT:
6997 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
7001 fputs_filtered ("Saw new packet start in middle of old one\n",
7003 return -1; /* Start a new packet, count retries. */
7006 unsigned char pktcsum;
7012 check_0 = readchar (remote_timeout);
7014 check_1 = readchar (remote_timeout);
7016 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
7019 fputs_filtered ("Timeout in checksum, retrying\n",
7023 else if (check_0 < 0 || check_1 < 0)
7026 fputs_filtered ("Communication error in checksum\n",
7031 /* Don't recompute the checksum; with no ack packets we
7032 don't have any way to indicate a packet retransmission
7037 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
7038 if (csum == pktcsum)
7043 struct cleanup *old_chain;
7046 str = escape_buffer (buf, bc);
7047 old_chain = make_cleanup (xfree, str);
7048 fprintf_unfiltered (gdb_stdlog,
7049 "Bad checksum, sentsum=0x%x, "
7050 "csum=0x%x, buf=%s\n",
7051 pktcsum, csum, str);
7052 do_cleanups (old_chain);
7054 /* Number of characters in buffer ignoring trailing
7058 case '*': /* Run length encoding. */
7063 c = readchar (remote_timeout);
7065 repeat = c - ' ' + 3; /* Compute repeat count. */
7067 /* The character before ``*'' is repeated. */
7069 if (repeat > 0 && repeat <= 255 && bc > 0)
7071 if (bc + repeat - 1 >= *sizeof_buf - 1)
7073 /* Make some more room in the buffer. */
7074 *sizeof_buf += repeat;
7075 *buf_p = xrealloc (*buf_p, *sizeof_buf);
7079 memset (&buf[bc], buf[bc - 1], repeat);
7085 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
7089 if (bc >= *sizeof_buf - 1)
7091 /* Make some more room in the buffer. */
7093 *buf_p = xrealloc (*buf_p, *sizeof_buf);
7104 /* Read a packet from the remote machine, with error checking, and
7105 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
7106 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
7107 rather than timing out; this is used (in synchronous mode) to wait
7108 for a target that is is executing user code to stop. */
7109 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
7110 don't have to change all the calls to getpkt to deal with the
7111 return value, because at the moment I don't know what the right
7112 thing to do it for those. */
7120 timed_out = getpkt_sane (buf, sizeof_buf, forever);
7124 /* Read a packet from the remote machine, with error checking, and
7125 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
7126 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
7127 rather than timing out; this is used (in synchronous mode) to wait
7128 for a target that is is executing user code to stop. If FOREVER ==
7129 0, this function is allowed to time out gracefully and return an
7130 indication of this to the caller. Otherwise return the number of
7131 bytes read. If EXPECTING_NOTIF, consider receiving a notification
7132 enough reason to return to the caller. */
7135 getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
7136 int expecting_notif)
7138 struct remote_state *rs = get_remote_state ();
7144 /* We're reading a new response. Make sure we don't look at a
7145 previously cached response. */
7146 rs->cached_wait_status = 0;
7148 strcpy (*buf, "timeout");
7151 timeout = watchdog > 0 ? watchdog : -1;
7152 else if (expecting_notif)
7153 timeout = 0; /* There should already be a char in the buffer. If
7156 timeout = remote_timeout;
7160 /* Process any number of notifications, and then return when
7164 /* If we get a timeout or bad checksm, retry up to MAX_TRIES
7166 for (tries = 1; tries <= MAX_TRIES; tries++)
7168 /* This can loop forever if the remote side sends us
7169 characters continuously, but if it pauses, we'll get
7170 SERIAL_TIMEOUT from readchar because of timeout. Then
7171 we'll count that as a retry.
7173 Note that even when forever is set, we will only wait
7174 forever prior to the start of a packet. After that, we
7175 expect characters to arrive at a brisk pace. They should
7176 show up within remote_timeout intervals. */
7178 c = readchar (timeout);
7179 while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
7181 if (c == SERIAL_TIMEOUT)
7183 if (expecting_notif)
7184 return -1; /* Don't complain, it's normal to not get
7185 anything in this case. */
7187 if (forever) /* Watchdog went off? Kill the target. */
7191 error (_("Watchdog timeout has expired. Target detached."));
7194 fputs_filtered ("Timed out.\n", gdb_stdlog);
7198 /* We've found the start of a packet or notification.
7199 Now collect the data. */
7200 val = read_frame (buf, sizeof_buf);
7205 serial_write (remote_desc, "-", 1);
7208 if (tries > MAX_TRIES)
7210 /* We have tried hard enough, and just can't receive the
7211 packet/notification. Give up. */
7212 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
7214 /* Skip the ack char if we're in no-ack mode. */
7215 if (!rs->noack_mode)
7216 serial_write (remote_desc, "+", 1);
7220 /* If we got an ordinary packet, return that to our caller. */
7225 struct cleanup *old_chain;
7228 str = escape_buffer (*buf, val);
7229 old_chain = make_cleanup (xfree, str);
7230 fprintf_unfiltered (gdb_stdlog, "Packet received: %s\n", str);
7231 do_cleanups (old_chain);
7234 /* Skip the ack char if we're in no-ack mode. */
7235 if (!rs->noack_mode)
7236 serial_write (remote_desc, "+", 1);
7240 /* If we got a notification, handle it, and go back to looking
7244 gdb_assert (c == '%');
7248 struct cleanup *old_chain;
7251 str = escape_buffer (*buf, val);
7252 old_chain = make_cleanup (xfree, str);
7253 fprintf_unfiltered (gdb_stdlog,
7254 " Notification received: %s\n",
7256 do_cleanups (old_chain);
7259 handle_notification (*buf, val);
7261 /* Notifications require no acknowledgement. */
7263 if (expecting_notif)
7270 getpkt_sane (char **buf, long *sizeof_buf, int forever)
7272 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0);
7276 getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever)
7278 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1);
7283 remote_kill (struct target_ops *ops)
7285 /* Use catch_errors so the user can quit from gdb even when we
7286 aren't on speaking terms with the remote system. */
7287 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
7289 /* Don't wait for it to die. I'm not really sure it matters whether
7290 we do or not. For the existing stubs, kill is a noop. */
7291 target_mourn_inferior ();
7295 remote_vkill (int pid, struct remote_state *rs)
7297 if (remote_protocol_packets[PACKET_vKill].support == PACKET_DISABLE)
7300 /* Tell the remote target to detach. */
7301 sprintf (rs->buf, "vKill;%x", pid);
7303 getpkt (&rs->buf, &rs->buf_size, 0);
7305 if (packet_ok (rs->buf,
7306 &remote_protocol_packets[PACKET_vKill]) == PACKET_OK)
7308 else if (remote_protocol_packets[PACKET_vKill].support == PACKET_DISABLE)
7315 extended_remote_kill (struct target_ops *ops)
7318 int pid = ptid_get_pid (inferior_ptid);
7319 struct remote_state *rs = get_remote_state ();
7321 res = remote_vkill (pid, rs);
7322 if (res == -1 && !remote_multi_process_p (rs))
7324 /* Don't try 'k' on a multi-process aware stub -- it has no way
7325 to specify the pid. */
7329 getpkt (&rs->buf, &rs->buf_size, 0);
7330 if (rs->buf[0] != 'O' || rs->buf[0] != 'K')
7333 /* Don't wait for it to die. I'm not really sure it matters whether
7334 we do or not. For the existing stubs, kill is a noop. */
7340 error (_("Can't kill process"));
7342 target_mourn_inferior ();
7346 remote_mourn (struct target_ops *ops)
7348 remote_mourn_1 (ops);
7351 /* Worker function for remote_mourn. */
7353 remote_mourn_1 (struct target_ops *target)
7355 unpush_target (target);
7357 /* remote_close takes care of doing most of the clean up. */
7358 generic_mourn_inferior ();
7362 extended_remote_mourn_1 (struct target_ops *target)
7364 struct remote_state *rs = get_remote_state ();
7366 /* In case we got here due to an error, but we're going to stay
7368 rs->waiting_for_stop_reply = 0;
7370 /* We're no longer interested in these events. */
7371 discard_pending_stop_replies (ptid_get_pid (inferior_ptid));
7373 /* If the current general thread belonged to the process we just
7374 detached from or has exited, the remote side current general
7375 thread becomes undefined. Considering a case like this:
7377 - We just got here due to a detach.
7378 - The process that we're detaching from happens to immediately
7379 report a global breakpoint being hit in non-stop mode, in the
7380 same thread we had selected before.
7381 - GDB attaches to this process again.
7382 - This event happens to be the next event we handle.
7384 GDB would consider that the current general thread didn't need to
7385 be set on the stub side (with Hg), since for all it knew,
7386 GENERAL_THREAD hadn't changed.
7388 Notice that although in all-stop mode, the remote server always
7389 sets the current thread to the thread reporting the stop event,
7390 that doesn't happen in non-stop mode; in non-stop, the stub *must
7391 not* change the current thread when reporting a breakpoint hit,
7392 due to the decoupling of event reporting and event handling.
7394 To keep things simple, we always invalidate our notion of the
7396 record_currthread (minus_one_ptid);
7398 /* Unlike "target remote", we do not want to unpush the target; then
7399 the next time the user says "run", we won't be connected. */
7401 /* Call common code to mark the inferior as not running. */
7402 generic_mourn_inferior ();
7404 if (!have_inferiors ())
7406 if (!remote_multi_process_p (rs))
7408 /* Check whether the target is running now - some remote stubs
7409 automatically restart after kill. */
7411 getpkt (&rs->buf, &rs->buf_size, 0);
7413 if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
7415 /* Assume that the target has been restarted. Set
7416 inferior_ptid so that bits of core GDB realizes
7417 there's something here, e.g., so that the user can
7418 say "kill" again. */
7419 inferior_ptid = magic_null_ptid;
7426 extended_remote_mourn (struct target_ops *ops)
7428 extended_remote_mourn_1 (ops);
7432 extended_remote_run (char *args)
7434 struct remote_state *rs = get_remote_state ();
7437 /* If the user has disabled vRun support, or we have detected that
7438 support is not available, do not try it. */
7439 if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE)
7442 strcpy (rs->buf, "vRun;");
7443 len = strlen (rs->buf);
7445 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
7446 error (_("Remote file name too long for run packet"));
7447 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len, 0);
7449 gdb_assert (args != NULL);
7452 struct cleanup *back_to;
7456 argv = gdb_buildargv (args);
7457 back_to = make_cleanup ((void (*) (void *)) freeargv, argv);
7458 for (i = 0; argv[i] != NULL; i++)
7460 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
7461 error (_("Argument list too long for run packet"));
7462 rs->buf[len++] = ';';
7463 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len, 0);
7465 do_cleanups (back_to);
7468 rs->buf[len++] = '\0';
7471 getpkt (&rs->buf, &rs->buf_size, 0);
7473 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]) == PACKET_OK)
7475 /* We have a wait response; we don't need it, though. All is well. */
7478 else if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE)
7479 /* It wasn't disabled before, but it is now. */
7483 if (remote_exec_file[0] == '\0')
7484 error (_("Running the default executable on the remote target failed; "
7485 "try \"set remote exec-file\"?"));
7487 error (_("Running \"%s\" on the remote target failed"),
7492 /* In the extended protocol we want to be able to do things like
7493 "run" and have them basically work as expected. So we need
7494 a special create_inferior function. We support changing the
7495 executable file and the command line arguments, but not the
7499 extended_remote_create_inferior_1 (char *exec_file, char *args,
7500 char **env, int from_tty)
7502 /* If running asynchronously, register the target file descriptor
7503 with the event loop. */
7504 if (target_can_async_p ())
7505 target_async (inferior_event_handler, 0);
7507 /* Now restart the remote server. */
7508 if (extended_remote_run (args) == -1)
7510 /* vRun was not supported. Fail if we need it to do what the
7512 if (remote_exec_file[0])
7513 error (_("Remote target does not support \"set remote exec-file\""));
7515 error (_("Remote target does not support \"set args\" or run <ARGS>"));
7517 /* Fall back to "R". */
7518 extended_remote_restart ();
7521 if (!have_inferiors ())
7523 /* Clean up from the last time we ran, before we mark the target
7524 running again. This will mark breakpoints uninserted, and
7525 get_offsets may insert breakpoints. */
7526 init_thread_list ();
7527 init_wait_for_inferior ();
7530 /* Now mark the inferior as running before we do anything else. */
7531 inferior_ptid = magic_null_ptid;
7533 /* Now, if we have thread information, update inferior_ptid. */
7534 inferior_ptid = remote_current_thread (inferior_ptid);
7536 remote_add_inferior (ptid_get_pid (inferior_ptid), 0);
7537 add_thread_silent (inferior_ptid);
7539 /* Get updated offsets, if the stub uses qOffsets. */
7544 extended_remote_create_inferior (struct target_ops *ops,
7545 char *exec_file, char *args,
7546 char **env, int from_tty)
7548 extended_remote_create_inferior_1 (exec_file, args, env, from_tty);
7552 /* Insert a breakpoint. On targets that have software breakpoint
7553 support, we ask the remote target to do the work; on targets
7554 which don't, we insert a traditional memory breakpoint. */
7557 remote_insert_breakpoint (struct gdbarch *gdbarch,
7558 struct bp_target_info *bp_tgt)
7560 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
7561 If it succeeds, then set the support to PACKET_ENABLE. If it
7562 fails, and the user has explicitly requested the Z support then
7563 report an error, otherwise, mark it disabled and go on. */
7565 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
7567 CORE_ADDR addr = bp_tgt->placed_address;
7568 struct remote_state *rs;
7572 gdbarch_remote_breakpoint_from_pc (gdbarch, &addr, &bpsize);
7574 rs = get_remote_state ();
7580 addr = (ULONGEST) remote_address_masked (addr);
7581 p += hexnumstr (p, addr);
7582 sprintf (p, ",%d", bpsize);
7585 getpkt (&rs->buf, &rs->buf_size, 0);
7587 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
7592 bp_tgt->placed_address = addr;
7593 bp_tgt->placed_size = bpsize;
7595 case PACKET_UNKNOWN:
7600 return memory_insert_breakpoint (gdbarch, bp_tgt);
7604 remote_remove_breakpoint (struct gdbarch *gdbarch,
7605 struct bp_target_info *bp_tgt)
7607 CORE_ADDR addr = bp_tgt->placed_address;
7608 struct remote_state *rs = get_remote_state ();
7610 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
7618 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
7619 p += hexnumstr (p, addr);
7620 sprintf (p, ",%d", bp_tgt->placed_size);
7623 getpkt (&rs->buf, &rs->buf_size, 0);
7625 return (rs->buf[0] == 'E');
7628 return memory_remove_breakpoint (gdbarch, bp_tgt);
7632 watchpoint_to_Z_packet (int type)
7637 return Z_PACKET_WRITE_WP;
7640 return Z_PACKET_READ_WP;
7643 return Z_PACKET_ACCESS_WP;
7646 internal_error (__FILE__, __LINE__,
7647 _("hw_bp_to_z: bad watchpoint type %d"), type);
7652 remote_insert_watchpoint (CORE_ADDR addr, int len, int type,
7653 struct expression *cond)
7655 struct remote_state *rs = get_remote_state ();
7657 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
7659 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
7662 sprintf (rs->buf, "Z%x,", packet);
7663 p = strchr (rs->buf, '\0');
7664 addr = remote_address_masked (addr);
7665 p += hexnumstr (p, (ULONGEST) addr);
7666 sprintf (p, ",%x", len);
7669 getpkt (&rs->buf, &rs->buf_size, 0);
7671 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
7675 case PACKET_UNKNOWN:
7680 internal_error (__FILE__, __LINE__,
7681 _("remote_insert_watchpoint: reached end of function"));
7686 remote_remove_watchpoint (CORE_ADDR addr, int len, int type,
7687 struct expression *cond)
7689 struct remote_state *rs = get_remote_state ();
7691 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
7693 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
7696 sprintf (rs->buf, "z%x,", packet);
7697 p = strchr (rs->buf, '\0');
7698 addr = remote_address_masked (addr);
7699 p += hexnumstr (p, (ULONGEST) addr);
7700 sprintf (p, ",%x", len);
7702 getpkt (&rs->buf, &rs->buf_size, 0);
7704 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
7707 case PACKET_UNKNOWN:
7712 internal_error (__FILE__, __LINE__,
7713 _("remote_remove_watchpoint: reached end of function"));
7717 int remote_hw_watchpoint_limit = -1;
7718 int remote_hw_breakpoint_limit = -1;
7721 remote_check_watch_resources (int type, int cnt, int ot)
7723 if (type == bp_hardware_breakpoint)
7725 if (remote_hw_breakpoint_limit == 0)
7727 else if (remote_hw_breakpoint_limit < 0)
7729 else if (cnt <= remote_hw_breakpoint_limit)
7734 if (remote_hw_watchpoint_limit == 0)
7736 else if (remote_hw_watchpoint_limit < 0)
7740 else if (cnt <= remote_hw_watchpoint_limit)
7747 remote_stopped_by_watchpoint (void)
7749 return remote_stopped_by_watchpoint_p;
7753 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
7757 if (remote_stopped_by_watchpoint ())
7759 *addr_p = remote_watch_data_address;
7768 remote_insert_hw_breakpoint (struct gdbarch *gdbarch,
7769 struct bp_target_info *bp_tgt)
7772 struct remote_state *rs;
7775 /* The length field should be set to the size of a breakpoint
7776 instruction, even though we aren't inserting one ourselves. */
7778 gdbarch_remote_breakpoint_from_pc
7779 (gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
7781 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
7784 rs = get_remote_state ();
7791 addr = remote_address_masked (bp_tgt->placed_address);
7792 p += hexnumstr (p, (ULONGEST) addr);
7793 sprintf (p, ",%x", bp_tgt->placed_size);
7796 getpkt (&rs->buf, &rs->buf_size, 0);
7798 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
7801 case PACKET_UNKNOWN:
7806 internal_error (__FILE__, __LINE__,
7807 _("remote_insert_hw_breakpoint: reached end of function"));
7812 remote_remove_hw_breakpoint (struct gdbarch *gdbarch,
7813 struct bp_target_info *bp_tgt)
7816 struct remote_state *rs = get_remote_state ();
7819 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
7826 addr = remote_address_masked (bp_tgt->placed_address);
7827 p += hexnumstr (p, (ULONGEST) addr);
7828 sprintf (p, ",%x", bp_tgt->placed_size);
7831 getpkt (&rs->buf, &rs->buf_size, 0);
7833 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
7836 case PACKET_UNKNOWN:
7841 internal_error (__FILE__, __LINE__,
7842 _("remote_remove_hw_breakpoint: reached end of function"));
7845 /* Table used by the crc32 function to calcuate the checksum. */
7847 static unsigned long crc32_table[256] =
7850 static unsigned long
7851 crc32 (const unsigned char *buf, int len, unsigned int crc)
7853 if (!crc32_table[1])
7855 /* Initialize the CRC table and the decoding table. */
7859 for (i = 0; i < 256; i++)
7861 for (c = i << 24, j = 8; j > 0; --j)
7862 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
7869 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
7875 /* Verify memory using the "qCRC:" request. */
7878 remote_verify_memory (struct target_ops *ops,
7879 const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
7881 struct remote_state *rs = get_remote_state ();
7882 unsigned long host_crc, target_crc;
7885 /* FIXME: assumes lma can fit into long. */
7886 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
7887 (long) lma, (long) size);
7890 /* Be clever; compute the host_crc before waiting for target
7892 host_crc = crc32 (data, size, 0xffffffff);
7894 getpkt (&rs->buf, &rs->buf_size, 0);
7895 if (rs->buf[0] == 'E')
7898 if (rs->buf[0] != 'C')
7899 error (_("remote target does not support this operation"));
7901 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
7902 target_crc = target_crc * 16 + fromhex (*tmp);
7904 return (host_crc == target_crc);
7907 /* compare-sections command
7909 With no arguments, compares each loadable section in the exec bfd
7910 with the same memory range on the target, and reports mismatches.
7911 Useful for verifying the image on the target against the exec file. */
7914 compare_sections_command (char *args, int from_tty)
7917 struct cleanup *old_chain;
7919 const char *sectname;
7927 error (_("command cannot be used without an exec file"));
7929 for (s = exec_bfd->sections; s; s = s->next)
7931 if (!(s->flags & SEC_LOAD))
7932 continue; /* Skip non-loadable section. */
7934 size = bfd_get_section_size (s);
7936 continue; /* Skip zero-length section. */
7938 sectname = bfd_get_section_name (exec_bfd, s);
7939 if (args && strcmp (args, sectname) != 0)
7940 continue; /* Not the section selected by user. */
7942 matched = 1; /* Do this section. */
7945 sectdata = xmalloc (size);
7946 old_chain = make_cleanup (xfree, sectdata);
7947 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
7949 res = target_verify_memory (sectdata, lma, size);
7952 error (_("target memory fault, section %s, range %s -- %s"), sectname,
7953 paddress (target_gdbarch, lma),
7954 paddress (target_gdbarch, lma + size));
7956 printf_filtered ("Section %s, range %s -- %s: ", sectname,
7957 paddress (target_gdbarch, lma),
7958 paddress (target_gdbarch, lma + size));
7960 printf_filtered ("matched.\n");
7963 printf_filtered ("MIS-MATCHED!\n");
7967 do_cleanups (old_chain);
7970 warning (_("One or more sections of the remote executable does not match\n\
7971 the loaded file\n"));
7972 if (args && !matched)
7973 printf_filtered (_("No loaded section named '%s'.\n"), args);
7976 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
7977 into remote target. The number of bytes written to the remote
7978 target is returned, or -1 for error. */
7981 remote_write_qxfer (struct target_ops *ops, const char *object_name,
7982 const char *annex, const gdb_byte *writebuf,
7983 ULONGEST offset, LONGEST len,
7984 struct packet_config *packet)
7988 struct remote_state *rs = get_remote_state ();
7989 int max_size = get_memory_write_packet_size ();
7991 if (packet->support == PACKET_DISABLE)
7994 /* Insert header. */
7995 i = snprintf (rs->buf, max_size,
7996 "qXfer:%s:write:%s:%s:",
7997 object_name, annex ? annex : "",
7998 phex_nz (offset, sizeof offset));
7999 max_size -= (i + 1);
8001 /* Escape as much data as fits into rs->buf. */
8002 buf_len = remote_escape_output
8003 (writebuf, len, (rs->buf + i), &max_size, max_size);
8005 if (putpkt_binary (rs->buf, i + buf_len) < 0
8006 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
8007 || packet_ok (rs->buf, packet) != PACKET_OK)
8010 unpack_varlen_hex (rs->buf, &n);
8014 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
8015 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
8016 number of bytes read is returned, or 0 for EOF, or -1 for error.
8017 The number of bytes read may be less than LEN without indicating an
8018 EOF. PACKET is checked and updated to indicate whether the remote
8019 target supports this object. */
8022 remote_read_qxfer (struct target_ops *ops, const char *object_name,
8024 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
8025 struct packet_config *packet)
8027 static char *finished_object;
8028 static char *finished_annex;
8029 static ULONGEST finished_offset;
8031 struct remote_state *rs = get_remote_state ();
8032 LONGEST i, n, packet_len;
8034 if (packet->support == PACKET_DISABLE)
8037 /* Check whether we've cached an end-of-object packet that matches
8039 if (finished_object)
8041 if (strcmp (object_name, finished_object) == 0
8042 && strcmp (annex ? annex : "", finished_annex) == 0
8043 && offset == finished_offset)
8046 /* Otherwise, we're now reading something different. Discard
8048 xfree (finished_object);
8049 xfree (finished_annex);
8050 finished_object = NULL;
8051 finished_annex = NULL;
8054 /* Request only enough to fit in a single packet. The actual data
8055 may not, since we don't know how much of it will need to be escaped;
8056 the target is free to respond with slightly less data. We subtract
8057 five to account for the response type and the protocol frame. */
8058 n = min (get_remote_packet_size () - 5, len);
8059 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
8060 object_name, annex ? annex : "",
8061 phex_nz (offset, sizeof offset),
8062 phex_nz (n, sizeof n));
8063 i = putpkt (rs->buf);
8068 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
8069 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
8072 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
8073 error (_("Unknown remote qXfer reply: %s"), rs->buf);
8075 /* 'm' means there is (or at least might be) more data after this
8076 batch. That does not make sense unless there's at least one byte
8077 of data in this reply. */
8078 if (rs->buf[0] == 'm' && packet_len == 1)
8079 error (_("Remote qXfer reply contained no data."));
8081 /* Got some data. */
8082 i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n);
8084 /* 'l' is an EOF marker, possibly including a final block of data,
8085 or possibly empty. If we have the final block of a non-empty
8086 object, record this fact to bypass a subsequent partial read. */
8087 if (rs->buf[0] == 'l' && offset + i > 0)
8089 finished_object = xstrdup (object_name);
8090 finished_annex = xstrdup (annex ? annex : "");
8091 finished_offset = offset + i;
8098 remote_xfer_partial (struct target_ops *ops, enum target_object object,
8099 const char *annex, gdb_byte *readbuf,
8100 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
8102 struct remote_state *rs;
8107 set_general_thread (inferior_ptid);
8109 rs = get_remote_state ();
8111 /* Handle memory using the standard memory routines. */
8112 if (object == TARGET_OBJECT_MEMORY)
8118 /* If the remote target is connected but not running, we should
8119 pass this request down to a lower stratum (e.g. the executable
8121 if (!target_has_execution)
8124 if (writebuf != NULL)
8125 xfered = remote_write_bytes (offset, writebuf, len);
8127 xfered = remote_read_bytes (offset, readbuf, len);
8131 else if (xfered == 0 && errno == 0)
8137 /* Handle SPU memory using qxfer packets. */
8138 if (object == TARGET_OBJECT_SPU)
8141 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
8142 &remote_protocol_packets
8143 [PACKET_qXfer_spu_read]);
8145 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
8146 &remote_protocol_packets
8147 [PACKET_qXfer_spu_write]);
8150 /* Handle extra signal info using qxfer packets. */
8151 if (object == TARGET_OBJECT_SIGNAL_INFO)
8154 return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len,
8155 &remote_protocol_packets
8156 [PACKET_qXfer_siginfo_read]);
8158 return remote_write_qxfer (ops, "siginfo", annex,
8159 writebuf, offset, len,
8160 &remote_protocol_packets
8161 [PACKET_qXfer_siginfo_write]);
8164 if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
8167 return remote_read_qxfer (ops, "statictrace", annex,
8168 readbuf, offset, len,
8169 &remote_protocol_packets
8170 [PACKET_qXfer_statictrace_read]);
8175 /* Only handle flash writes. */
8176 if (writebuf != NULL)
8182 case TARGET_OBJECT_FLASH:
8183 xfered = remote_flash_write (ops, offset, len, writebuf);
8187 else if (xfered == 0 && errno == 0)
8197 /* Map pre-existing objects onto letters. DO NOT do this for new
8198 objects!!! Instead specify new query packets. */
8201 case TARGET_OBJECT_AVR:
8205 case TARGET_OBJECT_AUXV:
8206 gdb_assert (annex == NULL);
8207 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
8208 &remote_protocol_packets[PACKET_qXfer_auxv]);
8210 case TARGET_OBJECT_AVAILABLE_FEATURES:
8211 return remote_read_qxfer
8212 (ops, "features", annex, readbuf, offset, len,
8213 &remote_protocol_packets[PACKET_qXfer_features]);
8215 case TARGET_OBJECT_LIBRARIES:
8216 return remote_read_qxfer
8217 (ops, "libraries", annex, readbuf, offset, len,
8218 &remote_protocol_packets[PACKET_qXfer_libraries]);
8220 case TARGET_OBJECT_MEMORY_MAP:
8221 gdb_assert (annex == NULL);
8222 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
8223 &remote_protocol_packets[PACKET_qXfer_memory_map]);
8225 case TARGET_OBJECT_OSDATA:
8226 /* Should only get here if we're connected. */
8227 gdb_assert (remote_desc);
8228 return remote_read_qxfer
8229 (ops, "osdata", annex, readbuf, offset, len,
8230 &remote_protocol_packets[PACKET_qXfer_osdata]);
8232 case TARGET_OBJECT_THREADS:
8233 gdb_assert (annex == NULL);
8234 return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,
8235 &remote_protocol_packets[PACKET_qXfer_threads]);
8241 /* Note: a zero OFFSET and LEN can be used to query the minimum
8243 if (offset == 0 && len == 0)
8244 return (get_remote_packet_size ());
8245 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
8246 large enough let the caller deal with it. */
8247 if (len < get_remote_packet_size ())
8249 len = get_remote_packet_size ();
8251 /* Except for querying the minimum buffer size, target must be open. */
8253 error (_("remote query is only available after target open"));
8255 gdb_assert (annex != NULL);
8256 gdb_assert (readbuf != NULL);
8262 /* We used one buffer char for the remote protocol q command and
8263 another for the query type. As the remote protocol encapsulation
8264 uses 4 chars plus one extra in case we are debugging
8265 (remote_debug), we have PBUFZIZ - 7 left to pack the query
8268 while (annex[i] && (i < (get_remote_packet_size () - 8)))
8270 /* Bad caller may have sent forbidden characters. */
8271 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
8276 gdb_assert (annex[i] == '\0');
8278 i = putpkt (rs->buf);
8282 getpkt (&rs->buf, &rs->buf_size, 0);
8283 strcpy ((char *) readbuf, rs->buf);
8285 return strlen ((char *) readbuf);
8289 remote_search_memory (struct target_ops* ops,
8290 CORE_ADDR start_addr, ULONGEST search_space_len,
8291 const gdb_byte *pattern, ULONGEST pattern_len,
8292 CORE_ADDR *found_addrp)
8294 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
8295 struct remote_state *rs = get_remote_state ();
8296 int max_size = get_memory_write_packet_size ();
8297 struct packet_config *packet =
8298 &remote_protocol_packets[PACKET_qSearch_memory];
8299 /* Number of packet bytes used to encode the pattern;
8300 this could be more than PATTERN_LEN due to escape characters. */
8301 int escaped_pattern_len;
8302 /* Amount of pattern that was encodable in the packet. */
8303 int used_pattern_len;
8306 ULONGEST found_addr;
8308 /* Don't go to the target if we don't have to.
8309 This is done before checking packet->support to avoid the possibility that
8310 a success for this edge case means the facility works in general. */
8311 if (pattern_len > search_space_len)
8313 if (pattern_len == 0)
8315 *found_addrp = start_addr;
8319 /* If we already know the packet isn't supported, fall back to the simple
8320 way of searching memory. */
8322 if (packet->support == PACKET_DISABLE)
8324 /* Target doesn't provided special support, fall back and use the
8325 standard support (copy memory and do the search here). */
8326 return simple_search_memory (ops, start_addr, search_space_len,
8327 pattern, pattern_len, found_addrp);
8330 /* Insert header. */
8331 i = snprintf (rs->buf, max_size,
8332 "qSearch:memory:%s;%s;",
8333 phex_nz (start_addr, addr_size),
8334 phex_nz (search_space_len, sizeof (search_space_len)));
8335 max_size -= (i + 1);
8337 /* Escape as much data as fits into rs->buf. */
8338 escaped_pattern_len =
8339 remote_escape_output (pattern, pattern_len, (rs->buf + i),
8340 &used_pattern_len, max_size);
8342 /* Bail if the pattern is too large. */
8343 if (used_pattern_len != pattern_len)
8344 error (_("Pattern is too large to transmit to remote target."));
8346 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
8347 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
8348 || packet_ok (rs->buf, packet) != PACKET_OK)
8350 /* The request may not have worked because the command is not
8351 supported. If so, fall back to the simple way. */
8352 if (packet->support == PACKET_DISABLE)
8354 return simple_search_memory (ops, start_addr, search_space_len,
8355 pattern, pattern_len, found_addrp);
8360 if (rs->buf[0] == '0')
8362 else if (rs->buf[0] == '1')
8365 if (rs->buf[1] != ',')
8366 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
8367 unpack_varlen_hex (rs->buf + 2, &found_addr);
8368 *found_addrp = found_addr;
8371 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
8377 remote_rcmd (char *command,
8378 struct ui_file *outbuf)
8380 struct remote_state *rs = get_remote_state ();
8384 error (_("remote rcmd is only available after target open"));
8386 /* Send a NULL command across as an empty command. */
8387 if (command == NULL)
8390 /* The query prefix. */
8391 strcpy (rs->buf, "qRcmd,");
8392 p = strchr (rs->buf, '\0');
8394 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/)
8395 > get_remote_packet_size ())
8396 error (_("\"monitor\" command ``%s'' is too long."), command);
8398 /* Encode the actual command. */
8399 bin2hex ((gdb_byte *) command, p, 0);
8401 if (putpkt (rs->buf) < 0)
8402 error (_("Communication problem with target."));
8404 /* get/display the response */
8409 /* XXX - see also remote_get_noisy_reply(). */
8411 getpkt (&rs->buf, &rs->buf_size, 0);
8414 error (_("Target does not support this command."));
8415 if (buf[0] == 'O' && buf[1] != 'K')
8417 remote_console_output (buf + 1); /* 'O' message from stub. */
8420 if (strcmp (buf, "OK") == 0)
8422 if (strlen (buf) == 3 && buf[0] == 'E'
8423 && isdigit (buf[1]) && isdigit (buf[2]))
8425 error (_("Protocol error with Rcmd"));
8427 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
8429 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
8431 fputc_unfiltered (c, outbuf);
8437 static VEC(mem_region_s) *
8438 remote_memory_map (struct target_ops *ops)
8440 VEC(mem_region_s) *result = NULL;
8441 char *text = target_read_stralloc (¤t_target,
8442 TARGET_OBJECT_MEMORY_MAP, NULL);
8446 struct cleanup *back_to = make_cleanup (xfree, text);
8448 result = parse_memory_map (text);
8449 do_cleanups (back_to);
8456 packet_command (char *args, int from_tty)
8458 struct remote_state *rs = get_remote_state ();
8461 error (_("command can only be used with remote target"));
8464 error (_("remote-packet command requires packet text as argument"));
8466 puts_filtered ("sending: ");
8467 print_packet (args);
8468 puts_filtered ("\n");
8471 getpkt (&rs->buf, &rs->buf_size, 0);
8472 puts_filtered ("received: ");
8473 print_packet (rs->buf);
8474 puts_filtered ("\n");
8478 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
8480 static void display_thread_info (struct gdb_ext_thread_info *info);
8482 static void threadset_test_cmd (char *cmd, int tty);
8484 static void threadalive_test (char *cmd, int tty);
8486 static void threadlist_test_cmd (char *cmd, int tty);
8488 int get_and_display_threadinfo (threadref *ref);
8490 static void threadinfo_test_cmd (char *cmd, int tty);
8492 static int thread_display_step (threadref *ref, void *context);
8494 static void threadlist_update_test_cmd (char *cmd, int tty);
8496 static void init_remote_threadtests (void);
8498 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
8501 threadset_test_cmd (char *cmd, int tty)
8503 int sample_thread = SAMPLE_THREAD;
8505 printf_filtered (_("Remote threadset test\n"));
8506 set_general_thread (sample_thread);
8511 threadalive_test (char *cmd, int tty)
8513 int sample_thread = SAMPLE_THREAD;
8514 int pid = ptid_get_pid (inferior_ptid);
8515 ptid_t ptid = ptid_build (pid, 0, sample_thread);
8517 if (remote_thread_alive (ptid))
8518 printf_filtered ("PASS: Thread alive test\n");
8520 printf_filtered ("FAIL: Thread alive test\n");
8523 void output_threadid (char *title, threadref *ref);
8526 output_threadid (char *title, threadref *ref)
8530 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
8532 printf_filtered ("%s %s\n", title, (&hexid[0]));
8536 threadlist_test_cmd (char *cmd, int tty)
8539 threadref nextthread;
8540 int done, result_count;
8541 threadref threadlist[3];
8543 printf_filtered ("Remote Threadlist test\n");
8544 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
8545 &result_count, &threadlist[0]))
8546 printf_filtered ("FAIL: threadlist test\n");
8549 threadref *scan = threadlist;
8550 threadref *limit = scan + result_count;
8552 while (scan < limit)
8553 output_threadid (" thread ", scan++);
8558 display_thread_info (struct gdb_ext_thread_info *info)
8560 output_threadid ("Threadid: ", &info->threadid);
8561 printf_filtered ("Name: %s\n ", info->shortname);
8562 printf_filtered ("State: %s\n", info->display);
8563 printf_filtered ("other: %s\n\n", info->more_display);
8567 get_and_display_threadinfo (threadref *ref)
8571 struct gdb_ext_thread_info threadinfo;
8573 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
8574 | TAG_MOREDISPLAY | TAG_DISPLAY;
8575 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
8576 display_thread_info (&threadinfo);
8581 threadinfo_test_cmd (char *cmd, int tty)
8583 int athread = SAMPLE_THREAD;
8587 int_to_threadref (&thread, athread);
8588 printf_filtered ("Remote Threadinfo test\n");
8589 if (!get_and_display_threadinfo (&thread))
8590 printf_filtered ("FAIL cannot get thread info\n");
8594 thread_display_step (threadref *ref, void *context)
8596 /* output_threadid(" threadstep ",ref); *//* simple test */
8597 return get_and_display_threadinfo (ref);
8601 threadlist_update_test_cmd (char *cmd, int tty)
8603 printf_filtered ("Remote Threadlist update test\n");
8604 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
8608 init_remote_threadtests (void)
8610 add_com ("tlist", class_obscure, threadlist_test_cmd,
8611 _("Fetch and print the remote list of "
8612 "thread identifiers, one pkt only"));
8613 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
8614 _("Fetch and display info about one thread"));
8615 add_com ("tset", class_obscure, threadset_test_cmd,
8616 _("Test setting to a different thread"));
8617 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
8618 _("Iterate through updating all remote thread info"));
8619 add_com ("talive", class_obscure, threadalive_test,
8620 _(" Remote thread alive test "));
8625 /* Convert a thread ID to a string. Returns the string in a static
8629 remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
8631 static char buf[64];
8632 struct remote_state *rs = get_remote_state ();
8634 if (ptid_is_pid (ptid))
8636 /* Printing an inferior target id. */
8638 /* When multi-process extensions are off, there's no way in the
8639 remote protocol to know the remote process id, if there's any
8640 at all. There's one exception --- when we're connected with
8641 target extended-remote, and we manually attached to a process
8642 with "attach PID". We don't record anywhere a flag that
8643 allows us to distinguish that case from the case of
8644 connecting with extended-remote and the stub already being
8645 attached to a process, and reporting yes to qAttached, hence
8646 no smart special casing here. */
8647 if (!remote_multi_process_p (rs))
8649 xsnprintf (buf, sizeof buf, "Remote target");
8653 return normal_pid_to_str (ptid);
8657 if (ptid_equal (magic_null_ptid, ptid))
8658 xsnprintf (buf, sizeof buf, "Thread <main>");
8659 else if (remote_multi_process_p (rs))
8660 xsnprintf (buf, sizeof buf, "Thread %d.%ld",
8661 ptid_get_pid (ptid), ptid_get_tid (ptid));
8663 xsnprintf (buf, sizeof buf, "Thread %ld",
8664 ptid_get_tid (ptid));
8669 /* Get the address of the thread local variable in OBJFILE which is
8670 stored at OFFSET within the thread local storage for thread PTID. */
8673 remote_get_thread_local_address (struct target_ops *ops,
8674 ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
8676 if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
8678 struct remote_state *rs = get_remote_state ();
8680 char *endp = rs->buf + get_remote_packet_size ();
8681 enum packet_result result;
8683 strcpy (p, "qGetTLSAddr:");
8685 p = write_ptid (p, endp, ptid);
8687 p += hexnumstr (p, offset);
8689 p += hexnumstr (p, lm);
8693 getpkt (&rs->buf, &rs->buf_size, 0);
8694 result = packet_ok (rs->buf,
8695 &remote_protocol_packets[PACKET_qGetTLSAddr]);
8696 if (result == PACKET_OK)
8700 unpack_varlen_hex (rs->buf, &result);
8703 else if (result == PACKET_UNKNOWN)
8704 throw_error (TLS_GENERIC_ERROR,
8705 _("Remote target doesn't support qGetTLSAddr packet"));
8707 throw_error (TLS_GENERIC_ERROR,
8708 _("Remote target failed to process qGetTLSAddr request"));
8711 throw_error (TLS_GENERIC_ERROR,
8712 _("TLS not supported or disabled on this target"));
8717 /* Provide thread local base, i.e. Thread Information Block address.
8718 Returns 1 if ptid is found and thread_local_base is non zero. */
8721 remote_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
8723 if (remote_protocol_packets[PACKET_qGetTIBAddr].support != PACKET_DISABLE)
8725 struct remote_state *rs = get_remote_state ();
8727 char *endp = rs->buf + get_remote_packet_size ();
8728 enum packet_result result;
8730 strcpy (p, "qGetTIBAddr:");
8732 p = write_ptid (p, endp, ptid);
8736 getpkt (&rs->buf, &rs->buf_size, 0);
8737 result = packet_ok (rs->buf,
8738 &remote_protocol_packets[PACKET_qGetTIBAddr]);
8739 if (result == PACKET_OK)
8743 unpack_varlen_hex (rs->buf, &result);
8745 *addr = (CORE_ADDR) result;
8748 else if (result == PACKET_UNKNOWN)
8749 error (_("Remote target doesn't support qGetTIBAddr packet"));
8751 error (_("Remote target failed to process qGetTIBAddr request"));
8754 error (_("qGetTIBAddr not supported or disabled on this target"));
8759 /* Support for inferring a target description based on the current
8760 architecture and the size of a 'g' packet. While the 'g' packet
8761 can have any size (since optional registers can be left off the
8762 end), some sizes are easily recognizable given knowledge of the
8763 approximate architecture. */
8765 struct remote_g_packet_guess
8768 const struct target_desc *tdesc;
8770 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
8771 DEF_VEC_O(remote_g_packet_guess_s);
8773 struct remote_g_packet_data
8775 VEC(remote_g_packet_guess_s) *guesses;
8778 static struct gdbarch_data *remote_g_packet_data_handle;
8781 remote_g_packet_data_init (struct obstack *obstack)
8783 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
8787 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
8788 const struct target_desc *tdesc)
8790 struct remote_g_packet_data *data
8791 = gdbarch_data (gdbarch, remote_g_packet_data_handle);
8792 struct remote_g_packet_guess new_guess, *guess;
8795 gdb_assert (tdesc != NULL);
8798 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
8800 if (guess->bytes == bytes)
8801 internal_error (__FILE__, __LINE__,
8802 _("Duplicate g packet description added for size %d"),
8805 new_guess.bytes = bytes;
8806 new_guess.tdesc = tdesc;
8807 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
8810 /* Return 1 if remote_read_description would do anything on this target
8811 and architecture, 0 otherwise. */
8814 remote_read_description_p (struct target_ops *target)
8816 struct remote_g_packet_data *data
8817 = gdbarch_data (target_gdbarch, remote_g_packet_data_handle);
8819 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
8825 static const struct target_desc *
8826 remote_read_description (struct target_ops *target)
8828 struct remote_g_packet_data *data
8829 = gdbarch_data (target_gdbarch, remote_g_packet_data_handle);
8831 /* Do not try this during initial connection, when we do not know
8832 whether there is a running but stopped thread. */
8833 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
8836 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
8838 struct remote_g_packet_guess *guess;
8840 int bytes = send_g_packet ();
8843 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
8845 if (guess->bytes == bytes)
8846 return guess->tdesc;
8848 /* We discard the g packet. A minor optimization would be to
8849 hold on to it, and fill the register cache once we have selected
8850 an architecture, but it's too tricky to do safely. */
8856 /* Remote file transfer support. This is host-initiated I/O, not
8857 target-initiated; for target-initiated, see remote-fileio.c. */
8859 /* If *LEFT is at least the length of STRING, copy STRING to
8860 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8861 decrease *LEFT. Otherwise raise an error. */
8864 remote_buffer_add_string (char **buffer, int *left, char *string)
8866 int len = strlen (string);
8869 error (_("Packet too long for target."));
8871 memcpy (*buffer, string, len);
8875 /* NUL-terminate the buffer as a convenience, if there is
8881 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
8882 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8883 decrease *LEFT. Otherwise raise an error. */
8886 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
8889 if (2 * len > *left)
8890 error (_("Packet too long for target."));
8892 bin2hex (bytes, *buffer, len);
8896 /* NUL-terminate the buffer as a convenience, if there is
8902 /* If *LEFT is large enough, convert VALUE to hex and add it to
8903 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8904 decrease *LEFT. Otherwise raise an error. */
8907 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
8909 int len = hexnumlen (value);
8912 error (_("Packet too long for target."));
8914 hexnumstr (*buffer, value);
8918 /* NUL-terminate the buffer as a convenience, if there is
8924 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
8925 value, *REMOTE_ERRNO to the remote error number or zero if none
8926 was included, and *ATTACHMENT to point to the start of the annex
8927 if any. The length of the packet isn't needed here; there may
8928 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
8930 Return 0 if the packet could be parsed, -1 if it could not. If
8931 -1 is returned, the other variables may not be initialized. */
8934 remote_hostio_parse_result (char *buffer, int *retcode,
8935 int *remote_errno, char **attachment)
8942 if (buffer[0] != 'F')
8946 *retcode = strtol (&buffer[1], &p, 16);
8947 if (errno != 0 || p == &buffer[1])
8950 /* Check for ",errno". */
8954 *remote_errno = strtol (p + 1, &p2, 16);
8955 if (errno != 0 || p + 1 == p2)
8960 /* Check for ";attachment". If there is no attachment, the
8961 packet should end here. */
8964 *attachment = p + 1;
8967 else if (*p == '\0')
8973 /* Send a prepared I/O packet to the target and read its response.
8974 The prepared packet is in the global RS->BUF before this function
8975 is called, and the answer is there when we return.
8977 COMMAND_BYTES is the length of the request to send, which may include
8978 binary data. WHICH_PACKET is the packet configuration to check
8979 before attempting a packet. If an error occurs, *REMOTE_ERRNO
8980 is set to the error number and -1 is returned. Otherwise the value
8981 returned by the function is returned.
8983 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
8984 attachment is expected; an error will be reported if there's a
8985 mismatch. If one is found, *ATTACHMENT will be set to point into
8986 the packet buffer and *ATTACHMENT_LEN will be set to the
8987 attachment's length. */
8990 remote_hostio_send_command (int command_bytes, int which_packet,
8991 int *remote_errno, char **attachment,
8992 int *attachment_len)
8994 struct remote_state *rs = get_remote_state ();
8995 int ret, bytes_read;
8996 char *attachment_tmp;
8999 || remote_protocol_packets[which_packet].support == PACKET_DISABLE)
9001 *remote_errno = FILEIO_ENOSYS;
9005 putpkt_binary (rs->buf, command_bytes);
9006 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0);
9008 /* If it timed out, something is wrong. Don't try to parse the
9012 *remote_errno = FILEIO_EINVAL;
9016 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
9019 *remote_errno = FILEIO_EINVAL;
9021 case PACKET_UNKNOWN:
9022 *remote_errno = FILEIO_ENOSYS;
9028 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno,
9031 *remote_errno = FILEIO_EINVAL;
9035 /* Make sure we saw an attachment if and only if we expected one. */
9036 if ((attachment_tmp == NULL && attachment != NULL)
9037 || (attachment_tmp != NULL && attachment == NULL))
9039 *remote_errno = FILEIO_EINVAL;
9043 /* If an attachment was found, it must point into the packet buffer;
9044 work out how many bytes there were. */
9045 if (attachment_tmp != NULL)
9047 *attachment = attachment_tmp;
9048 *attachment_len = bytes_read - (*attachment - rs->buf);
9054 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
9055 remote file descriptor, or -1 if an error occurs (and set
9059 remote_hostio_open (const char *filename, int flags, int mode,
9062 struct remote_state *rs = get_remote_state ();
9064 int left = get_remote_packet_size () - 1;
9066 remote_buffer_add_string (&p, &left, "vFile:open:");
9068 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
9070 remote_buffer_add_string (&p, &left, ",");
9072 remote_buffer_add_int (&p, &left, flags);
9073 remote_buffer_add_string (&p, &left, ",");
9075 remote_buffer_add_int (&p, &left, mode);
9077 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open,
9078 remote_errno, NULL, NULL);
9081 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
9082 Return the number of bytes written, or -1 if an error occurs (and
9083 set *REMOTE_ERRNO). */
9086 remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
9087 ULONGEST offset, int *remote_errno)
9089 struct remote_state *rs = get_remote_state ();
9091 int left = get_remote_packet_size ();
9094 remote_buffer_add_string (&p, &left, "vFile:pwrite:");
9096 remote_buffer_add_int (&p, &left, fd);
9097 remote_buffer_add_string (&p, &left, ",");
9099 remote_buffer_add_int (&p, &left, offset);
9100 remote_buffer_add_string (&p, &left, ",");
9102 p += remote_escape_output (write_buf, len, p, &out_len,
9103 get_remote_packet_size () - (p - rs->buf));
9105 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite,
9106 remote_errno, NULL, NULL);
9109 /* Read up to LEN bytes FD on the remote target into READ_BUF
9110 Return the number of bytes read, or -1 if an error occurs (and
9111 set *REMOTE_ERRNO). */
9114 remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
9115 ULONGEST offset, int *remote_errno)
9117 struct remote_state *rs = get_remote_state ();
9120 int left = get_remote_packet_size ();
9121 int ret, attachment_len;
9124 remote_buffer_add_string (&p, &left, "vFile:pread:");
9126 remote_buffer_add_int (&p, &left, fd);
9127 remote_buffer_add_string (&p, &left, ",");
9129 remote_buffer_add_int (&p, &left, len);
9130 remote_buffer_add_string (&p, &left, ",");
9132 remote_buffer_add_int (&p, &left, offset);
9134 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread,
9135 remote_errno, &attachment,
9141 read_len = remote_unescape_input (attachment, attachment_len,
9143 if (read_len != ret)
9144 error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
9149 /* Close FD on the remote target. Return 0, or -1 if an error occurs
9150 (and set *REMOTE_ERRNO). */
9153 remote_hostio_close (int fd, int *remote_errno)
9155 struct remote_state *rs = get_remote_state ();
9157 int left = get_remote_packet_size () - 1;
9159 remote_buffer_add_string (&p, &left, "vFile:close:");
9161 remote_buffer_add_int (&p, &left, fd);
9163 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close,
9164 remote_errno, NULL, NULL);
9167 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
9168 occurs (and set *REMOTE_ERRNO). */
9171 remote_hostio_unlink (const char *filename, int *remote_errno)
9173 struct remote_state *rs = get_remote_state ();
9175 int left = get_remote_packet_size () - 1;
9177 remote_buffer_add_string (&p, &left, "vFile:unlink:");
9179 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
9182 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink,
9183 remote_errno, NULL, NULL);
9187 remote_fileio_errno_to_host (int errnum)
9211 case FILEIO_ENOTDIR:
9231 case FILEIO_ENAMETOOLONG:
9232 return ENAMETOOLONG;
9238 remote_hostio_error (int errnum)
9240 int host_error = remote_fileio_errno_to_host (errnum);
9242 if (host_error == -1)
9243 error (_("Unknown remote I/O error %d"), errnum);
9245 error (_("Remote I/O error: %s"), safe_strerror (host_error));
9249 remote_hostio_close_cleanup (void *opaque)
9251 int fd = *(int *) opaque;
9254 remote_hostio_close (fd, &remote_errno);
9259 remote_bfd_iovec_open (struct bfd *abfd, void *open_closure)
9261 const char *filename = bfd_get_filename (abfd);
9262 int fd, remote_errno;
9265 gdb_assert (remote_filename_p (filename));
9267 fd = remote_hostio_open (filename + 7, FILEIO_O_RDONLY, 0, &remote_errno);
9270 errno = remote_fileio_errno_to_host (remote_errno);
9271 bfd_set_error (bfd_error_system_call);
9275 stream = xmalloc (sizeof (int));
9281 remote_bfd_iovec_close (struct bfd *abfd, void *stream)
9283 int fd = *(int *)stream;
9288 /* Ignore errors on close; these may happen if the remote
9289 connection was already torn down. */
9290 remote_hostio_close (fd, &remote_errno);
9296 remote_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
9297 file_ptr nbytes, file_ptr offset)
9299 int fd = *(int *)stream;
9301 file_ptr pos, bytes;
9304 while (nbytes > pos)
9306 bytes = remote_hostio_pread (fd, (char *)buf + pos, nbytes - pos,
9307 offset + pos, &remote_errno);
9309 /* Success, but no bytes, means end-of-file. */
9313 errno = remote_fileio_errno_to_host (remote_errno);
9314 bfd_set_error (bfd_error_system_call);
9325 remote_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
9327 /* FIXME: We should probably implement remote_hostio_stat. */
9328 sb->st_size = INT_MAX;
9333 remote_filename_p (const char *filename)
9335 return strncmp (filename, "remote:", 7) == 0;
9339 remote_bfd_open (const char *remote_file, const char *target)
9341 return bfd_openr_iovec (remote_file, target,
9342 remote_bfd_iovec_open, NULL,
9343 remote_bfd_iovec_pread,
9344 remote_bfd_iovec_close,
9345 remote_bfd_iovec_stat);
9349 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
9351 struct cleanup *back_to, *close_cleanup;
9352 int retcode, fd, remote_errno, bytes, io_size;
9355 int bytes_in_buffer;
9360 error (_("command can only be used with remote target"));
9362 file = fopen (local_file, "rb");
9364 perror_with_name (local_file);
9365 back_to = make_cleanup_fclose (file);
9367 fd = remote_hostio_open (remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
9369 0700, &remote_errno);
9371 remote_hostio_error (remote_errno);
9373 /* Send up to this many bytes at once. They won't all fit in the
9374 remote packet limit, so we'll transfer slightly fewer. */
9375 io_size = get_remote_packet_size ();
9376 buffer = xmalloc (io_size);
9377 make_cleanup (xfree, buffer);
9379 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
9381 bytes_in_buffer = 0;
9384 while (bytes_in_buffer || !saw_eof)
9388 bytes = fread (buffer + bytes_in_buffer, 1,
9389 io_size - bytes_in_buffer,
9394 error (_("Error reading %s."), local_file);
9397 /* EOF. Unless there is something still in the
9398 buffer from the last iteration, we are done. */
9400 if (bytes_in_buffer == 0)
9408 bytes += bytes_in_buffer;
9409 bytes_in_buffer = 0;
9411 retcode = remote_hostio_pwrite (fd, buffer, bytes,
9412 offset, &remote_errno);
9415 remote_hostio_error (remote_errno);
9416 else if (retcode == 0)
9417 error (_("Remote write of %d bytes returned 0!"), bytes);
9418 else if (retcode < bytes)
9420 /* Short write. Save the rest of the read data for the next
9422 bytes_in_buffer = bytes - retcode;
9423 memmove (buffer, buffer + retcode, bytes_in_buffer);
9429 discard_cleanups (close_cleanup);
9430 if (remote_hostio_close (fd, &remote_errno))
9431 remote_hostio_error (remote_errno);
9434 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
9435 do_cleanups (back_to);
9439 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
9441 struct cleanup *back_to, *close_cleanup;
9442 int fd, remote_errno, bytes, io_size;
9448 error (_("command can only be used with remote target"));
9450 fd = remote_hostio_open (remote_file, FILEIO_O_RDONLY, 0, &remote_errno);
9452 remote_hostio_error (remote_errno);
9454 file = fopen (local_file, "wb");
9456 perror_with_name (local_file);
9457 back_to = make_cleanup_fclose (file);
9459 /* Send up to this many bytes at once. They won't all fit in the
9460 remote packet limit, so we'll transfer slightly fewer. */
9461 io_size = get_remote_packet_size ();
9462 buffer = xmalloc (io_size);
9463 make_cleanup (xfree, buffer);
9465 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
9470 bytes = remote_hostio_pread (fd, buffer, io_size, offset, &remote_errno);
9472 /* Success, but no bytes, means end-of-file. */
9475 remote_hostio_error (remote_errno);
9479 bytes = fwrite (buffer, 1, bytes, file);
9481 perror_with_name (local_file);
9484 discard_cleanups (close_cleanup);
9485 if (remote_hostio_close (fd, &remote_errno))
9486 remote_hostio_error (remote_errno);
9489 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
9490 do_cleanups (back_to);
9494 remote_file_delete (const char *remote_file, int from_tty)
9496 int retcode, remote_errno;
9499 error (_("command can only be used with remote target"));
9501 retcode = remote_hostio_unlink (remote_file, &remote_errno);
9503 remote_hostio_error (remote_errno);
9506 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
9510 remote_put_command (char *args, int from_tty)
9512 struct cleanup *back_to;
9516 error_no_arg (_("file to put"));
9518 argv = gdb_buildargv (args);
9519 back_to = make_cleanup_freeargv (argv);
9520 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
9521 error (_("Invalid parameters to remote put"));
9523 remote_file_put (argv[0], argv[1], from_tty);
9525 do_cleanups (back_to);
9529 remote_get_command (char *args, int from_tty)
9531 struct cleanup *back_to;
9535 error_no_arg (_("file to get"));
9537 argv = gdb_buildargv (args);
9538 back_to = make_cleanup_freeargv (argv);
9539 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
9540 error (_("Invalid parameters to remote get"));
9542 remote_file_get (argv[0], argv[1], from_tty);
9544 do_cleanups (back_to);
9548 remote_delete_command (char *args, int from_tty)
9550 struct cleanup *back_to;
9554 error_no_arg (_("file to delete"));
9556 argv = gdb_buildargv (args);
9557 back_to = make_cleanup_freeargv (argv);
9558 if (argv[0] == NULL || argv[1] != NULL)
9559 error (_("Invalid parameters to remote delete"));
9561 remote_file_delete (argv[0], from_tty);
9563 do_cleanups (back_to);
9567 remote_command (char *args, int from_tty)
9569 help_list (remote_cmdlist, "remote ", -1, gdb_stdout);
9573 remote_can_execute_reverse (void)
9575 if (remote_protocol_packets[PACKET_bs].support == PACKET_ENABLE
9576 || remote_protocol_packets[PACKET_bc].support == PACKET_ENABLE)
9583 remote_supports_non_stop (void)
9589 remote_supports_multi_process (void)
9591 struct remote_state *rs = get_remote_state ();
9593 return remote_multi_process_p (rs);
9597 remote_supports_cond_tracepoints (void)
9599 struct remote_state *rs = get_remote_state ();
9601 return rs->cond_tracepoints;
9605 remote_supports_fast_tracepoints (void)
9607 struct remote_state *rs = get_remote_state ();
9609 return rs->fast_tracepoints;
9613 remote_supports_static_tracepoints (void)
9615 struct remote_state *rs = get_remote_state ();
9617 return rs->static_tracepoints;
9621 remote_trace_init (void)
9624 remote_get_noisy_reply (&target_buf, &target_buf_size);
9625 if (strcmp (target_buf, "OK") != 0)
9626 error (_("Target does not support this command."));
9629 static void free_actions_list (char **actions_list);
9630 static void free_actions_list_cleanup_wrapper (void *);
9632 free_actions_list_cleanup_wrapper (void *al)
9634 free_actions_list (al);
9638 free_actions_list (char **actions_list)
9642 if (actions_list == 0)
9645 for (ndx = 0; actions_list[ndx]; ndx++)
9646 xfree (actions_list[ndx]);
9648 xfree (actions_list);
9651 /* Recursive routine to walk through command list including loops, and
9652 download packets for each command. */
9655 remote_download_command_source (int num, ULONGEST addr,
9656 struct command_line *cmds)
9658 struct remote_state *rs = get_remote_state ();
9659 struct command_line *cmd;
9661 for (cmd = cmds; cmd; cmd = cmd->next)
9663 QUIT; /* Allow user to bail out with ^C. */
9664 strcpy (rs->buf, "QTDPsrc:");
9665 encode_source_string (num, addr, "cmd", cmd->line,
9666 rs->buf + strlen (rs->buf),
9667 rs->buf_size - strlen (rs->buf));
9669 remote_get_noisy_reply (&target_buf, &target_buf_size);
9670 if (strcmp (target_buf, "OK"))
9671 warning (_("Target does not support source download."));
9673 if (cmd->control_type == while_control
9674 || cmd->control_type == while_stepping_control)
9676 remote_download_command_source (num, addr, *cmd->body_list);
9678 QUIT; /* Allow user to bail out with ^C. */
9679 strcpy (rs->buf, "QTDPsrc:");
9680 encode_source_string (num, addr, "cmd", "end",
9681 rs->buf + strlen (rs->buf),
9682 rs->buf_size - strlen (rs->buf));
9684 remote_get_noisy_reply (&target_buf, &target_buf_size);
9685 if (strcmp (target_buf, "OK"))
9686 warning (_("Target does not support source download."));
9692 remote_download_tracepoint (struct breakpoint *t)
9694 struct bp_location *loc;
9699 char **stepping_actions;
9701 struct cleanup *old_chain = NULL;
9702 struct agent_expr *aexpr;
9703 struct cleanup *aexpr_chain = NULL;
9706 /* Iterate over all the tracepoint locations. It's up to the target to
9707 notice multiple tracepoint packets with the same number but different
9708 addresses, and treat them as multiple locations. */
9709 for (loc = t->loc; loc; loc = loc->next)
9711 encode_actions (t, loc, &tdp_actions, &stepping_actions);
9712 old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
9714 (void) make_cleanup (free_actions_list_cleanup_wrapper,
9717 tpaddr = loc->address;
9718 sprintf_vma (addrbuf, tpaddr);
9719 sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number,
9720 addrbuf, /* address */
9721 (t->enable_state == bp_enabled ? 'E' : 'D'),
9722 t->step_count, t->pass_count);
9723 /* Fast tracepoints are mostly handled by the target, but we can
9724 tell the target how big of an instruction block should be moved
9726 if (t->type == bp_fast_tracepoint)
9728 /* Only test for support at download time; we may not know
9729 target capabilities at definition time. */
9730 if (remote_supports_fast_tracepoints ())
9734 if (gdbarch_fast_tracepoint_valid_at (target_gdbarch,
9735 tpaddr, &isize, NULL))
9736 sprintf (buf + strlen (buf), ":F%x", isize);
9738 /* If it passed validation at definition but fails now,
9739 something is very wrong. */
9740 internal_error (__FILE__, __LINE__,
9741 _("Fast tracepoint not "
9742 "valid during download"));
9745 /* Fast tracepoints are functionally identical to regular
9746 tracepoints, so don't take lack of support as a reason to
9747 give up on the trace run. */
9748 warning (_("Target does not support fast tracepoints, "
9749 "downloading %d as regular tracepoint"), t->number);
9751 else if (t->type == bp_static_tracepoint)
9753 /* Only test for support at download time; we may not know
9754 target capabilities at definition time. */
9755 if (remote_supports_static_tracepoints ())
9757 struct static_tracepoint_marker marker;
9759 if (target_static_tracepoint_marker_at (tpaddr, &marker))
9762 error (_("Static tracepoint not valid during download"));
9765 /* Fast tracepoints are functionally identical to regular
9766 tracepoints, so don't take lack of support as a reason
9767 to give up on the trace run. */
9768 error (_("Target does not support static tracepoints"));
9770 /* If the tracepoint has a conditional, make it into an agent
9771 expression and append to the definition. */
9774 /* Only test support at download time, we may not know target
9775 capabilities at definition time. */
9776 if (remote_supports_cond_tracepoints ())
9778 aexpr = gen_eval_for_expr (tpaddr, loc->cond);
9779 aexpr_chain = make_cleanup_free_agent_expr (aexpr);
9780 sprintf (buf + strlen (buf), ":X%x,", aexpr->len);
9781 pkt = buf + strlen (buf);
9782 for (ndx = 0; ndx < aexpr->len; ++ndx)
9783 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
9785 do_cleanups (aexpr_chain);
9788 warning (_("Target does not support conditional tracepoints, "
9789 "ignoring tp %d cond"), t->number);
9792 if (t->commands || *default_collect)
9795 remote_get_noisy_reply (&target_buf, &target_buf_size);
9796 if (strcmp (target_buf, "OK"))
9797 error (_("Target does not support tracepoints."));
9799 /* do_single_steps (t); */
9802 for (ndx = 0; tdp_actions[ndx]; ndx++)
9804 QUIT; /* Allow user to bail out with ^C. */
9805 sprintf (buf, "QTDP:-%x:%s:%s%c",
9806 t->number, addrbuf, /* address */
9808 ((tdp_actions[ndx + 1] || stepping_actions)
9811 remote_get_noisy_reply (&target_buf,
9813 if (strcmp (target_buf, "OK"))
9814 error (_("Error on target while setting tracepoints."));
9817 if (stepping_actions)
9819 for (ndx = 0; stepping_actions[ndx]; ndx++)
9821 QUIT; /* Allow user to bail out with ^C. */
9822 sprintf (buf, "QTDP:-%x:%s:%s%s%s",
9823 t->number, addrbuf, /* address */
9824 ((ndx == 0) ? "S" : ""),
9825 stepping_actions[ndx],
9826 (stepping_actions[ndx + 1] ? "-" : ""));
9828 remote_get_noisy_reply (&target_buf,
9830 if (strcmp (target_buf, "OK"))
9831 error (_("Error on target while setting tracepoints."));
9835 if (remote_protocol_packets[PACKET_TracepointSource].support
9840 strcpy (buf, "QTDPsrc:");
9841 encode_source_string (t->number, loc->address,
9842 "at", t->addr_string, buf + strlen (buf),
9843 2048 - strlen (buf));
9846 remote_get_noisy_reply (&target_buf, &target_buf_size);
9847 if (strcmp (target_buf, "OK"))
9848 warning (_("Target does not support source download."));
9852 strcpy (buf, "QTDPsrc:");
9853 encode_source_string (t->number, loc->address,
9854 "cond", t->cond_string, buf + strlen (buf),
9855 2048 - strlen (buf));
9857 remote_get_noisy_reply (&target_buf, &target_buf_size);
9858 if (strcmp (target_buf, "OK"))
9859 warning (_("Target does not support source download."));
9861 remote_download_command_source (t->number, loc->address,
9862 breakpoint_commands (t));
9865 do_cleanups (old_chain);
9870 remote_download_trace_state_variable (struct trace_state_variable *tsv)
9872 struct remote_state *rs = get_remote_state ();
9875 sprintf (rs->buf, "QTDV:%x:%s:%x:",
9876 tsv->number, phex ((ULONGEST) tsv->initial_value, 8), tsv->builtin);
9877 p = rs->buf + strlen (rs->buf);
9878 if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
9879 error (_("Trace state variable name too long for tsv definition packet"));
9880 p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, 0);
9883 remote_get_noisy_reply (&target_buf, &target_buf_size);
9884 if (*target_buf == '\0')
9885 error (_("Target does not support this command."));
9886 if (strcmp (target_buf, "OK") != 0)
9887 error (_("Error on target while downloading trace state variable."));
9891 remote_trace_set_readonly_regions (void)
9899 return; /* No information to give. */
9901 strcpy (target_buf, "QTro");
9902 for (s = exec_bfd->sections; s; s = s->next)
9904 char tmp1[40], tmp2[40];
9906 if ((s->flags & SEC_LOAD) == 0 ||
9907 /* (s->flags & SEC_CODE) == 0 || */
9908 (s->flags & SEC_READONLY) == 0)
9912 vma = bfd_get_section_vma (,s);
9913 size = bfd_get_section_size (s);
9914 sprintf_vma (tmp1, vma);
9915 sprintf_vma (tmp2, vma + size);
9916 sprintf (target_buf + strlen (target_buf),
9917 ":%s,%s", tmp1, tmp2);
9921 putpkt (target_buf);
9922 getpkt (&target_buf, &target_buf_size, 0);
9927 remote_trace_start (void)
9930 remote_get_noisy_reply (&target_buf, &target_buf_size);
9931 if (*target_buf == '\0')
9932 error (_("Target does not support this command."));
9933 if (strcmp (target_buf, "OK") != 0)
9934 error (_("Bogus reply from target: %s"), target_buf);
9938 remote_get_trace_status (struct trace_status *ts)
9941 /* FIXME we need to get register block size some other way. */
9942 extern int trace_regblock_size;
9944 trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
9946 putpkt ("qTStatus");
9947 p = remote_get_noisy_reply (&target_buf, &target_buf_size);
9949 /* If the remote target doesn't do tracing, flag it. */
9953 /* We're working with a live target. */
9956 /* Set some defaults. */
9957 ts->running_known = 0;
9958 ts->stop_reason = trace_stop_reason_unknown;
9959 ts->traceframe_count = -1;
9960 ts->buffer_free = 0;
9963 error (_("Bogus trace status reply from target: %s"), target_buf);
9965 parse_trace_status (p, ts);
9971 remote_trace_stop (void)
9974 remote_get_noisy_reply (&target_buf, &target_buf_size);
9975 if (*target_buf == '\0')
9976 error (_("Target does not support this command."));
9977 if (strcmp (target_buf, "OK") != 0)
9978 error (_("Bogus reply from target: %s"), target_buf);
9982 remote_trace_find (enum trace_find_type type, int num,
9983 ULONGEST addr1, ULONGEST addr2,
9986 struct remote_state *rs = get_remote_state ();
9988 int target_frameno = -1, target_tracept = -1;
9991 strcpy (p, "QTFrame:");
9992 p = strchr (p, '\0');
9996 sprintf (p, "%x", num);
9999 sprintf (p, "pc:%s", phex_nz (addr1, 0));
10002 sprintf (p, "tdp:%x", num);
10005 sprintf (p, "range:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
10007 case tfind_outside:
10008 sprintf (p, "outside:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
10011 error (_("Unknown trace find type %d"), type);
10015 reply = remote_get_noisy_reply (&(rs->buf), &sizeof_pkt);
10016 if (*reply == '\0')
10017 error (_("Target does not support this command."));
10019 while (reply && *reply)
10024 target_frameno = (int) strtol (p, &reply, 16);
10026 error (_("Unable to parse trace frame number"));
10027 if (target_frameno == -1)
10032 target_tracept = (int) strtol (p, &reply, 16);
10034 error (_("Unable to parse tracepoint number"));
10036 case 'O': /* "OK"? */
10037 if (reply[1] == 'K' && reply[2] == '\0')
10040 error (_("Bogus reply from target: %s"), reply);
10043 error (_("Bogus reply from target: %s"), reply);
10046 *tpp = target_tracept;
10047 return target_frameno;
10051 remote_get_trace_state_variable_value (int tsvnum, LONGEST *val)
10053 struct remote_state *rs = get_remote_state ();
10057 sprintf (rs->buf, "qTV:%x", tsvnum);
10059 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
10060 if (reply && *reply)
10064 unpack_varlen_hex (reply + 1, &uval);
10065 *val = (LONGEST) uval;
10073 remote_save_trace_data (const char *filename)
10075 struct remote_state *rs = get_remote_state ();
10079 strcpy (p, "QTSave:");
10081 if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
10082 error (_("Remote file name too long for trace save packet"));
10083 p += 2 * bin2hex ((gdb_byte *) filename, p, 0);
10086 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
10087 if (*reply != '\0')
10088 error (_("Target does not support this command."));
10089 if (strcmp (reply, "OK") != 0)
10090 error (_("Bogus reply from target: %s"), reply);
10094 /* This is basically a memory transfer, but needs to be its own packet
10095 because we don't know how the target actually organizes its trace
10096 memory, plus we want to be able to ask for as much as possible, but
10097 not be unhappy if we don't get as much as we ask for. */
10100 remote_get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
10102 struct remote_state *rs = get_remote_state ();
10108 strcpy (p, "qTBuffer:");
10110 p += hexnumstr (p, offset);
10112 p += hexnumstr (p, len);
10116 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
10117 if (reply && *reply)
10119 /* 'l' by itself means we're at the end of the buffer and
10120 there is nothing more to get. */
10124 /* Convert the reply into binary. Limit the number of bytes to
10125 convert according to our passed-in buffer size, rather than
10126 what was returned in the packet; if the target is
10127 unexpectedly generous and gives us a bigger reply than we
10128 asked for, we don't want to crash. */
10129 rslt = hex2bin (target_buf, buf, len);
10133 /* Something went wrong, flag as an error. */
10138 remote_set_disconnected_tracing (int val)
10140 struct remote_state *rs = get_remote_state ();
10142 if (rs->disconnected_tracing)
10146 sprintf (rs->buf, "QTDisconnected:%x", val);
10148 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
10149 if (*reply == '\0')
10150 error (_("Target does not support this command."));
10151 if (strcmp (reply, "OK") != 0)
10152 error (_("Bogus reply from target: %s"), reply);
10155 warning (_("Target does not support disconnected tracing."));
10159 remote_core_of_thread (struct target_ops *ops, ptid_t ptid)
10161 struct thread_info *info = find_thread_ptid (ptid);
10163 if (info && info->private)
10164 return info->private->core;
10169 remote_set_circular_trace_buffer (int val)
10171 struct remote_state *rs = get_remote_state ();
10174 sprintf (rs->buf, "QTBuffer:circular:%x", val);
10176 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
10177 if (*reply == '\0')
10178 error (_("Target does not support this command."));
10179 if (strcmp (reply, "OK") != 0)
10180 error (_("Bogus reply from target: %s"), reply);
10184 init_remote_ops (void)
10186 remote_ops.to_shortname = "remote";
10187 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
10188 remote_ops.to_doc =
10189 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
10190 Specify the serial device it is connected to\n\
10191 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
10192 remote_ops.to_open = remote_open;
10193 remote_ops.to_close = remote_close;
10194 remote_ops.to_detach = remote_detach;
10195 remote_ops.to_disconnect = remote_disconnect;
10196 remote_ops.to_resume = remote_resume;
10197 remote_ops.to_wait = remote_wait;
10198 remote_ops.to_fetch_registers = remote_fetch_registers;
10199 remote_ops.to_store_registers = remote_store_registers;
10200 remote_ops.to_prepare_to_store = remote_prepare_to_store;
10201 remote_ops.deprecated_xfer_memory = remote_xfer_memory;
10202 remote_ops.to_files_info = remote_files_info;
10203 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
10204 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
10205 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
10206 remote_ops.to_stopped_data_address = remote_stopped_data_address;
10207 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
10208 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
10209 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
10210 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
10211 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
10212 remote_ops.to_kill = remote_kill;
10213 remote_ops.to_load = generic_load;
10214 remote_ops.to_mourn_inferior = remote_mourn;
10215 remote_ops.to_notice_signals = remote_notice_signals;
10216 remote_ops.to_thread_alive = remote_thread_alive;
10217 remote_ops.to_find_new_threads = remote_threads_info;
10218 remote_ops.to_pid_to_str = remote_pid_to_str;
10219 remote_ops.to_extra_thread_info = remote_threads_extra_info;
10220 remote_ops.to_get_ada_task_ptid = remote_get_ada_task_ptid;
10221 remote_ops.to_stop = remote_stop;
10222 remote_ops.to_xfer_partial = remote_xfer_partial;
10223 remote_ops.to_rcmd = remote_rcmd;
10224 remote_ops.to_log_command = serial_log_command;
10225 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
10226 remote_ops.to_stratum = process_stratum;
10227 remote_ops.to_has_all_memory = default_child_has_all_memory;
10228 remote_ops.to_has_memory = default_child_has_memory;
10229 remote_ops.to_has_stack = default_child_has_stack;
10230 remote_ops.to_has_registers = default_child_has_registers;
10231 remote_ops.to_has_execution = default_child_has_execution;
10232 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
10233 remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
10234 remote_ops.to_magic = OPS_MAGIC;
10235 remote_ops.to_memory_map = remote_memory_map;
10236 remote_ops.to_flash_erase = remote_flash_erase;
10237 remote_ops.to_flash_done = remote_flash_done;
10238 remote_ops.to_read_description = remote_read_description;
10239 remote_ops.to_search_memory = remote_search_memory;
10240 remote_ops.to_can_async_p = remote_can_async_p;
10241 remote_ops.to_is_async_p = remote_is_async_p;
10242 remote_ops.to_async = remote_async;
10243 remote_ops.to_async_mask = remote_async_mask;
10244 remote_ops.to_terminal_inferior = remote_terminal_inferior;
10245 remote_ops.to_terminal_ours = remote_terminal_ours;
10246 remote_ops.to_supports_non_stop = remote_supports_non_stop;
10247 remote_ops.to_supports_multi_process = remote_supports_multi_process;
10248 remote_ops.to_trace_init = remote_trace_init;
10249 remote_ops.to_download_tracepoint = remote_download_tracepoint;
10250 remote_ops.to_download_trace_state_variable
10251 = remote_download_trace_state_variable;
10252 remote_ops.to_trace_set_readonly_regions = remote_trace_set_readonly_regions;
10253 remote_ops.to_trace_start = remote_trace_start;
10254 remote_ops.to_get_trace_status = remote_get_trace_status;
10255 remote_ops.to_trace_stop = remote_trace_stop;
10256 remote_ops.to_trace_find = remote_trace_find;
10257 remote_ops.to_get_trace_state_variable_value
10258 = remote_get_trace_state_variable_value;
10259 remote_ops.to_save_trace_data = remote_save_trace_data;
10260 remote_ops.to_upload_tracepoints = remote_upload_tracepoints;
10261 remote_ops.to_upload_trace_state_variables
10262 = remote_upload_trace_state_variables;
10263 remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data;
10264 remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
10265 remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
10266 remote_ops.to_core_of_thread = remote_core_of_thread;
10267 remote_ops.to_verify_memory = remote_verify_memory;
10268 remote_ops.to_get_tib_address = remote_get_tib_address;
10269 remote_ops.to_set_permissions = remote_set_permissions;
10270 remote_ops.to_static_tracepoint_marker_at
10271 = remote_static_tracepoint_marker_at;
10272 remote_ops.to_static_tracepoint_markers_by_strid
10273 = remote_static_tracepoint_markers_by_strid;
10276 /* Set up the extended remote vector by making a copy of the standard
10277 remote vector and adding to it. */
10280 init_extended_remote_ops (void)
10282 extended_remote_ops = remote_ops;
10284 extended_remote_ops.to_shortname = "extended-remote";
10285 extended_remote_ops.to_longname =
10286 "Extended remote serial target in gdb-specific protocol";
10287 extended_remote_ops.to_doc =
10288 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
10289 Specify the serial device it is connected to (e.g. /dev/ttya).";
10290 extended_remote_ops.to_open = extended_remote_open;
10291 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
10292 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
10293 extended_remote_ops.to_detach = extended_remote_detach;
10294 extended_remote_ops.to_attach = extended_remote_attach;
10295 extended_remote_ops.to_kill = extended_remote_kill;
10299 remote_can_async_p (void)
10301 if (!target_async_permitted)
10302 /* We only enable async when the user specifically asks for it. */
10305 /* We're async whenever the serial device is. */
10306 return remote_async_mask_value && serial_can_async_p (remote_desc);
10310 remote_is_async_p (void)
10312 if (!target_async_permitted)
10313 /* We only enable async when the user specifically asks for it. */
10316 /* We're async whenever the serial device is. */
10317 return remote_async_mask_value && serial_is_async_p (remote_desc);
10320 /* Pass the SERIAL event on and up to the client. One day this code
10321 will be able to delay notifying the client of an event until the
10322 point where an entire packet has been received. */
10324 static void (*async_client_callback) (enum inferior_event_type event_type,
10326 static void *async_client_context;
10327 static serial_event_ftype remote_async_serial_handler;
10330 remote_async_serial_handler (struct serial *scb, void *context)
10332 /* Don't propogate error information up to the client. Instead let
10333 the client find out about the error by querying the target. */
10334 async_client_callback (INF_REG_EVENT, async_client_context);
10338 remote_async_inferior_event_handler (gdb_client_data data)
10340 inferior_event_handler (INF_REG_EVENT, NULL);
10344 remote_async_get_pending_events_handler (gdb_client_data data)
10346 remote_get_pending_stop_replies ();
10350 remote_async (void (*callback) (enum inferior_event_type event_type,
10351 void *context), void *context)
10353 if (remote_async_mask_value == 0)
10354 internal_error (__FILE__, __LINE__,
10355 _("Calling remote_async when async is masked"));
10357 if (callback != NULL)
10359 serial_async (remote_desc, remote_async_serial_handler, NULL);
10360 async_client_callback = callback;
10361 async_client_context = context;
10364 serial_async (remote_desc, NULL, NULL);
10368 remote_async_mask (int new_mask)
10370 int curr_mask = remote_async_mask_value;
10372 remote_async_mask_value = new_mask;
10377 set_remote_cmd (char *args, int from_tty)
10379 help_list (remote_set_cmdlist, "set remote ", -1, gdb_stdout);
10383 show_remote_cmd (char *args, int from_tty)
10385 /* We can't just use cmd_show_list here, because we want to skip
10386 the redundant "show remote Z-packet" and the legacy aliases. */
10387 struct cleanup *showlist_chain;
10388 struct cmd_list_element *list = remote_show_cmdlist;
10390 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
10391 for (; list != NULL; list = list->next)
10392 if (strcmp (list->name, "Z-packet") == 0)
10394 else if (list->type == not_set_cmd)
10395 /* Alias commands are exactly like the original, except they
10396 don't have the normal type. */
10400 struct cleanup *option_chain
10401 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
10403 ui_out_field_string (uiout, "name", list->name);
10404 ui_out_text (uiout, ": ");
10405 if (list->type == show_cmd)
10406 do_setshow_command ((char *) NULL, from_tty, list);
10408 cmd_func (list, NULL, from_tty);
10409 /* Close the tuple. */
10410 do_cleanups (option_chain);
10413 /* Close the tuple. */
10414 do_cleanups (showlist_chain);
10418 /* Function to be called whenever a new objfile (shlib) is detected. */
10420 remote_new_objfile (struct objfile *objfile)
10422 if (remote_desc != 0) /* Have a remote connection. */
10423 remote_check_symbols (objfile);
10426 /* Pull all the tracepoints defined on the target and create local
10427 data structures representing them. We don't want to create real
10428 tracepoints yet, we don't want to mess up the user's existing
10432 remote_upload_tracepoints (struct uploaded_tp **utpp)
10434 struct remote_state *rs = get_remote_state ();
10437 /* Ask for a first packet of tracepoint definition. */
10439 getpkt (&rs->buf, &rs->buf_size, 0);
10441 while (*p && *p != 'l')
10443 parse_tracepoint_definition (p, utpp);
10444 /* Ask for another packet of tracepoint definition. */
10446 getpkt (&rs->buf, &rs->buf_size, 0);
10453 remote_upload_trace_state_variables (struct uploaded_tsv **utsvp)
10455 struct remote_state *rs = get_remote_state ();
10458 /* Ask for a first packet of variable definition. */
10460 getpkt (&rs->buf, &rs->buf_size, 0);
10462 while (*p && *p != 'l')
10464 parse_tsv_definition (p, utsvp);
10465 /* Ask for another packet of variable definition. */
10467 getpkt (&rs->buf, &rs->buf_size, 0);
10474 _initialize_remote (void)
10476 struct remote_state *rs;
10477 struct cmd_list_element *cmd;
10480 /* architecture specific data */
10481 remote_gdbarch_data_handle =
10482 gdbarch_data_register_post_init (init_remote_state);
10483 remote_g_packet_data_handle =
10484 gdbarch_data_register_pre_init (remote_g_packet_data_init);
10486 /* Initialize the per-target state. At the moment there is only one
10487 of these, not one per target. Only one target is active at a
10488 time. The default buffer size is unimportant; it will be expanded
10489 whenever a larger buffer is needed. */
10490 rs = get_remote_state_raw ();
10491 rs->buf_size = 400;
10492 rs->buf = xmalloc (rs->buf_size);
10494 init_remote_ops ();
10495 add_target (&remote_ops);
10497 init_extended_remote_ops ();
10498 add_target (&extended_remote_ops);
10500 /* Hook into new objfile notification. */
10501 observer_attach_new_objfile (remote_new_objfile);
10503 /* Set up signal handlers. */
10504 sigint_remote_token =
10505 create_async_signal_handler (async_remote_interrupt, NULL);
10506 sigint_remote_twice_token =
10507 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
10510 init_remote_threadtests ();
10513 /* set/show remote ... */
10515 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
10516 Remote protocol specific variables\n\
10517 Configure various remote-protocol specific variables such as\n\
10518 the packets being used"),
10519 &remote_set_cmdlist, "set remote ",
10520 0 /* allow-unknown */, &setlist);
10521 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
10522 Remote protocol specific variables\n\
10523 Configure various remote-protocol specific variables such as\n\
10524 the packets being used"),
10525 &remote_show_cmdlist, "show remote ",
10526 0 /* allow-unknown */, &showlist);
10528 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
10529 Compare section data on target to the exec file.\n\
10530 Argument is a single section name (default: all loaded sections)."),
10533 add_cmd ("packet", class_maintenance, packet_command, _("\
10534 Send an arbitrary packet to a remote target.\n\
10535 maintenance packet TEXT\n\
10536 If GDB is talking to an inferior via the GDB serial protocol, then\n\
10537 this command sends the string TEXT to the inferior, and displays the\n\
10538 response packet. GDB supplies the initial `$' character, and the\n\
10539 terminating `#' character and checksum."),
10542 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
10543 Set whether to send break if interrupted."), _("\
10544 Show whether to send break if interrupted."), _("\
10545 If set, a break, instead of a cntrl-c, is sent to the remote target."),
10546 set_remotebreak, show_remotebreak,
10547 &setlist, &showlist);
10548 cmd_name = "remotebreak";
10549 cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
10550 deprecate_cmd (cmd, "set remote interrupt-sequence");
10551 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
10552 cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
10553 deprecate_cmd (cmd, "show remote interrupt-sequence");
10555 add_setshow_enum_cmd ("interrupt-sequence", class_support,
10556 interrupt_sequence_modes, &interrupt_sequence_mode,
10558 Set interrupt sequence to remote target."), _("\
10559 Show interrupt sequence to remote target."), _("\
10560 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
10561 NULL, show_interrupt_sequence,
10562 &remote_set_cmdlist,
10563 &remote_show_cmdlist);
10565 add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
10566 &interrupt_on_connect, _("\
10567 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
10568 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
10569 If set, interrupt sequence is sent to remote target."),
10571 &remote_set_cmdlist, &remote_show_cmdlist);
10573 /* Install commands for configuring memory read/write packets. */
10575 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
10576 Set the maximum number of bytes per memory write packet (deprecated)."),
10578 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
10579 Show the maximum number of bytes per memory write packet (deprecated)."),
10581 add_cmd ("memory-write-packet-size", no_class,
10582 set_memory_write_packet_size, _("\
10583 Set the maximum number of bytes per memory-write packet.\n\
10584 Specify the number of bytes in a packet or 0 (zero) for the\n\
10585 default packet size. The actual limit is further reduced\n\
10586 dependent on the target. Specify ``fixed'' to disable the\n\
10587 further restriction and ``limit'' to enable that restriction."),
10588 &remote_set_cmdlist);
10589 add_cmd ("memory-read-packet-size", no_class,
10590 set_memory_read_packet_size, _("\
10591 Set the maximum number of bytes per memory-read packet.\n\
10592 Specify the number of bytes in a packet or 0 (zero) for the\n\
10593 default packet size. The actual limit is further reduced\n\
10594 dependent on the target. Specify ``fixed'' to disable the\n\
10595 further restriction and ``limit'' to enable that restriction."),
10596 &remote_set_cmdlist);
10597 add_cmd ("memory-write-packet-size", no_class,
10598 show_memory_write_packet_size,
10599 _("Show the maximum number of bytes per memory-write packet."),
10600 &remote_show_cmdlist);
10601 add_cmd ("memory-read-packet-size", no_class,
10602 show_memory_read_packet_size,
10603 _("Show the maximum number of bytes per memory-read packet."),
10604 &remote_show_cmdlist);
10606 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
10607 &remote_hw_watchpoint_limit, _("\
10608 Set the maximum number of target hardware watchpoints."), _("\
10609 Show the maximum number of target hardware watchpoints."), _("\
10610 Specify a negative limit for unlimited."),
10611 NULL, NULL, /* FIXME: i18n: The maximum
10612 number of target hardware
10613 watchpoints is %s. */
10614 &remote_set_cmdlist, &remote_show_cmdlist);
10615 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
10616 &remote_hw_breakpoint_limit, _("\
10617 Set the maximum number of target hardware breakpoints."), _("\
10618 Show the maximum number of target hardware breakpoints."), _("\
10619 Specify a negative limit for unlimited."),
10620 NULL, NULL, /* FIXME: i18n: The maximum
10621 number of target hardware
10622 breakpoints is %s. */
10623 &remote_set_cmdlist, &remote_show_cmdlist);
10625 add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
10626 &remote_address_size, _("\
10627 Set the maximum size of the address (in bits) in a memory packet."), _("\
10628 Show the maximum size of the address (in bits) in a memory packet."), NULL,
10630 NULL, /* FIXME: i18n: */
10631 &setlist, &showlist);
10633 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
10634 "X", "binary-download", 1);
10636 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
10637 "vCont", "verbose-resume", 0);
10639 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
10640 "QPassSignals", "pass-signals", 0);
10642 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
10643 "qSymbol", "symbol-lookup", 0);
10645 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
10646 "P", "set-register", 1);
10648 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
10649 "p", "fetch-register", 1);
10651 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
10652 "Z0", "software-breakpoint", 0);
10654 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
10655 "Z1", "hardware-breakpoint", 0);
10657 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
10658 "Z2", "write-watchpoint", 0);
10660 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
10661 "Z3", "read-watchpoint", 0);
10663 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
10664 "Z4", "access-watchpoint", 0);
10666 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
10667 "qXfer:auxv:read", "read-aux-vector", 0);
10669 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
10670 "qXfer:features:read", "target-features", 0);
10672 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
10673 "qXfer:libraries:read", "library-info", 0);
10675 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
10676 "qXfer:memory-map:read", "memory-map", 0);
10678 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
10679 "qXfer:spu:read", "read-spu-object", 0);
10681 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
10682 "qXfer:spu:write", "write-spu-object", 0);
10684 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
10685 "qXfer:osdata:read", "osdata", 0);
10687 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
10688 "qXfer:threads:read", "threads", 0);
10690 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
10691 "qXfer:siginfo:read", "read-siginfo-object", 0);
10693 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
10694 "qXfer:siginfo:write", "write-siginfo-object", 0);
10696 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
10697 "qGetTLSAddr", "get-thread-local-storage-address",
10700 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
10701 "qGetTIBAddr", "get-thread-information-block-address",
10704 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
10705 "bc", "reverse-continue", 0);
10707 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
10708 "bs", "reverse-step", 0);
10710 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
10711 "qSupported", "supported-packets", 0);
10713 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
10714 "qSearch:memory", "search-memory", 0);
10716 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
10717 "vFile:open", "hostio-open", 0);
10719 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
10720 "vFile:pread", "hostio-pread", 0);
10722 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
10723 "vFile:pwrite", "hostio-pwrite", 0);
10725 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
10726 "vFile:close", "hostio-close", 0);
10728 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
10729 "vFile:unlink", "hostio-unlink", 0);
10731 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
10732 "vAttach", "attach", 0);
10734 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
10737 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
10738 "QStartNoAckMode", "noack", 0);
10740 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
10741 "vKill", "kill", 0);
10743 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
10744 "qAttached", "query-attached", 0);
10746 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
10747 "ConditionalTracepoints",
10748 "conditional-tracepoints", 0);
10749 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
10750 "FastTracepoints", "fast-tracepoints", 0);
10752 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
10753 "TracepointSource", "TracepointSource", 0);
10755 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
10756 "QAllow", "allow", 0);
10758 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
10759 "StaticTracepoints", "static-tracepoints", 0);
10761 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
10762 "qXfer:statictrace:read", "read-sdata-object", 0);
10764 /* Keep the old ``set remote Z-packet ...'' working. Each individual
10765 Z sub-packet has its own set and show commands, but users may
10766 have sets to this variable in their .gdbinit files (or in their
10768 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
10769 &remote_Z_packet_detect, _("\
10770 Set use of remote protocol `Z' packets"), _("\
10771 Show use of remote protocol `Z' packets "), _("\
10772 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
10774 set_remote_protocol_Z_packet_cmd,
10775 show_remote_protocol_Z_packet_cmd,
10776 /* FIXME: i18n: Use of remote protocol
10777 `Z' packets is %s. */
10778 &remote_set_cmdlist, &remote_show_cmdlist);
10780 add_prefix_cmd ("remote", class_files, remote_command, _("\
10781 Manipulate files on the remote system\n\
10782 Transfer files to and from the remote target system."),
10783 &remote_cmdlist, "remote ",
10784 0 /* allow-unknown */, &cmdlist);
10786 add_cmd ("put", class_files, remote_put_command,
10787 _("Copy a local file to the remote system."),
10790 add_cmd ("get", class_files, remote_get_command,
10791 _("Copy a remote file to the local system."),
10794 add_cmd ("delete", class_files, remote_delete_command,
10795 _("Delete a remote file."),
10798 remote_exec_file = xstrdup ("");
10799 add_setshow_string_noescape_cmd ("exec-file", class_files,
10800 &remote_exec_file, _("\
10801 Set the remote pathname for \"run\""), _("\
10802 Show the remote pathname for \"run\""), NULL, NULL, NULL,
10803 &remote_set_cmdlist, &remote_show_cmdlist);
10805 /* Eventually initialize fileio. See fileio.c */
10806 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
10808 /* Take advantage of the fact that the LWP field is not used, to tag
10809 special ptids with it set to != 0. */
10810 magic_null_ptid = ptid_build (42000, 1, -1);
10811 not_sent_ptid = ptid_build (42000, 1, -2);
10812 any_thread_ptid = ptid_build (42000, 1, 0);
10814 target_buf_size = 2048;
10815 target_buf = xmalloc (target_buf_size);