1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
29 #include "exceptions.h"
31 /*#include "terminal.h" */
34 #include "gdb-stabs.h"
35 #include "gdbthread.h"
37 #include "remote-notif.h"
40 #include "gdb_assert.h"
43 #include "cli/cli-decode.h"
44 #include "cli/cli-setshow.h"
45 #include "target-descriptions.h"
47 #include "filestuff.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"
73 /* Temp hacks for tracepoint encoding migration. */
74 static char *target_buf
;
75 static long target_buf_size
;
77 /* The size to align memory write packets, when practical. The protocol
78 does not guarantee any alignment, and gdb will generate short
79 writes and unaligned writes, but even as a best-effort attempt this
80 can improve bulk transfers. For instance, if a write is misaligned
81 relative to the target's data bus, the stub may need to make an extra
82 round trip fetching data from the target. This doesn't make a
83 huge difference, but it's easy to do, so we try to be helpful.
85 The alignment chosen is arbitrary; usually data bus width is
86 important here, not the possibly larger cache line size. */
87 enum { REMOTE_ALIGN_WRITES
= 16 };
89 /* Prototypes for local functions. */
90 static void async_cleanup_sigint_signal_handler (void *dummy
);
91 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
92 static int getpkt_or_notif_sane (char **buf
, long *sizeof_buf
,
93 int forever
, int *is_notif
);
95 static void async_handle_remote_sigint (int);
96 static void async_handle_remote_sigint_twice (int);
98 static void remote_files_info (struct target_ops
*ignore
);
100 static void remote_prepare_to_store (struct target_ops
*self
,
101 struct regcache
*regcache
);
103 static void remote_open (char *name
, int from_tty
);
105 static void extended_remote_open (char *name
, int from_tty
);
107 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
);
109 static void remote_close (void);
111 static void remote_mourn (struct target_ops
*ops
);
113 static void extended_remote_restart (void);
115 static void extended_remote_mourn (struct target_ops
*);
117 static void remote_mourn_1 (struct target_ops
*);
119 static void remote_send (char **buf
, long *sizeof_buf_p
);
121 static int readchar (int timeout
);
123 static void remote_serial_write (const char *str
, int len
);
125 static void remote_kill (struct target_ops
*ops
);
127 static int tohex (int nib
);
129 static int remote_can_async_p (void);
131 static int remote_is_async_p (void);
133 static void remote_async (void (*callback
) (enum inferior_event_type event_type
,
134 void *context
), void *context
);
136 static void sync_remote_interrupt_twice (int signo
);
138 static void interrupt_query (void);
140 static void set_general_thread (struct ptid ptid
);
141 static void set_continue_thread (struct ptid ptid
);
143 static void get_offsets (void);
145 static void skip_frame (void);
147 static long read_frame (char **buf_p
, long *sizeof_buf
);
149 static int hexnumlen (ULONGEST num
);
151 static void init_remote_ops (void);
153 static void init_extended_remote_ops (void);
155 static void remote_stop (ptid_t
);
157 static int ishex (int ch
, int *val
);
159 static int stubhex (int ch
);
161 static int hexnumstr (char *, ULONGEST
);
163 static int hexnumnstr (char *, ULONGEST
, int);
165 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
167 static void print_packet (char *);
169 static void compare_sections_command (char *, int);
171 static void packet_command (char *, int);
173 static int stub_unpack_int (char *buff
, int fieldlength
);
175 static ptid_t
remote_current_thread (ptid_t oldptid
);
177 static void remote_find_new_threads (void);
179 static int fromhex (int a
);
181 static int putpkt_binary (char *buf
, int cnt
);
183 static void check_binary_download (CORE_ADDR addr
);
185 struct packet_config
;
187 static void show_packet_config_cmd (struct packet_config
*config
);
189 static void update_packet_config (struct packet_config
*config
);
191 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
192 struct cmd_list_element
*c
);
194 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
196 struct cmd_list_element
*c
,
199 static char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
200 static ptid_t
read_ptid (char *buf
, char **obuf
);
202 static void remote_set_permissions (void);
205 static int remote_get_trace_status (struct trace_status
*ts
);
207 static int remote_upload_tracepoints (struct uploaded_tp
**utpp
);
209 static int remote_upload_trace_state_variables (struct uploaded_tsv
**utsvp
);
211 static void remote_query_supported (void);
213 static void remote_check_symbols (void);
215 void _initialize_remote (void);
218 static void stop_reply_xfree (struct stop_reply
*);
219 static void remote_parse_stop_reply (char *, struct stop_reply
*);
220 static void push_stop_reply (struct stop_reply
*);
221 static void discard_pending_stop_replies_in_queue (struct remote_state
*);
222 static int peek_stop_reply (ptid_t ptid
);
224 static void remote_async_inferior_event_handler (gdb_client_data
);
226 static void remote_terminal_ours (void);
228 static int remote_read_description_p (struct target_ops
*target
);
230 static void remote_console_output (char *msg
);
232 static int remote_supports_cond_breakpoints (void);
234 static int remote_can_run_breakpoint_commands (void);
238 static struct cmd_list_element
*remote_cmdlist
;
240 /* For "set remote" and "show remote". */
242 static struct cmd_list_element
*remote_set_cmdlist
;
243 static struct cmd_list_element
*remote_show_cmdlist
;
245 /* Stub vCont actions support.
247 Each field is a boolean flag indicating whether the stub reports
248 support for the corresponding action. */
250 struct vCont_action_support
259 /* Controls whether GDB is willing to use range stepping. */
261 static int use_range_stepping
= 1;
263 #define OPAQUETHREADBYTES 8
265 /* a 64 bit opaque identifier */
266 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
268 /* About this many threadisds fit in a packet. */
270 #define MAXTHREADLISTRESULTS 32
272 /* Description of the remote protocol state for the currently
273 connected target. This is per-target state, and independent of the
274 selected architecture. */
278 /* A buffer to use for incoming packets, and its current size. The
279 buffer is grown dynamically for larger incoming packets.
280 Outgoing packets may also be constructed in this buffer.
281 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
282 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
287 /* True if we're going through initial connection setup (finding out
288 about the remote side's threads, relocating symbols, etc.). */
291 /* If we negotiated packet size explicitly (and thus can bypass
292 heuristics for the largest packet size that will not overflow
293 a buffer in the stub), this will be set to that packet size.
294 Otherwise zero, meaning to use the guessed size. */
295 long explicit_packet_size
;
297 /* remote_wait is normally called when the target is running and
298 waits for a stop reply packet. But sometimes we need to call it
299 when the target is already stopped. We can send a "?" packet
300 and have remote_wait read the response. Or, if we already have
301 the response, we can stash it in BUF and tell remote_wait to
302 skip calling getpkt. This flag is set when BUF contains a
303 stop reply packet and the target is not waiting. */
304 int cached_wait_status
;
306 /* True, if in no ack mode. That is, neither GDB nor the stub will
307 expect acks from each other. The connection is assumed to be
311 /* True if we're connected in extended remote mode. */
314 /* True if the stub reported support for multi-process
316 int multi_process_aware
;
318 /* True if we resumed the target and we're waiting for the target to
319 stop. In the mean time, we can't start another command/query.
320 The remote server wouldn't be ready to process it, so we'd
321 timeout waiting for a reply that would never come and eventually
322 we'd close the connection. This can happen in asynchronous mode
323 because we allow GDB commands while the target is running. */
324 int waiting_for_stop_reply
;
326 /* True if the stub reports support for non-stop mode. */
329 /* The status of the stub support for the various vCont actions. */
330 struct vCont_action_support supports_vCont
;
332 /* True if the stub reports support for conditional tracepoints. */
333 int cond_tracepoints
;
335 /* True if the stub reports support for target-side breakpoint
337 int cond_breakpoints
;
339 /* True if the stub reports support for target-side breakpoint
341 int breakpoint_commands
;
343 /* True if the stub reports support for fast tracepoints. */
344 int fast_tracepoints
;
346 /* True if the stub reports support for static tracepoints. */
347 int static_tracepoints
;
349 /* True if the stub reports support for installing tracepoint while
351 int install_in_trace
;
353 /* True if the stub can continue running a trace while GDB is
355 int disconnected_tracing
;
357 /* True if the stub reports support for enabling and disabling
358 tracepoints while a trace experiment is running. */
359 int enable_disable_tracepoints
;
361 /* True if the stub can collect strings using tracenz bytecode. */
364 /* True if the stub supports qXfer:libraries-svr4:read with a
366 int augmented_libraries_svr4_read
;
368 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
369 responded to that. */
372 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
373 remote_open knows that we don't have a file open when the program
375 struct serial
*remote_desc
;
377 /* These are the threads which we last sent to the remote system. The
378 TID member will be -1 for all or -2 for not sent yet. */
379 ptid_t general_thread
;
380 ptid_t continue_thread
;
382 /* This is the traceframe which we last selected on the remote system.
383 It will be -1 if no traceframe is selected. */
384 int remote_traceframe_number
;
386 char *last_pass_packet
;
388 /* The last QProgramSignals packet sent to the target. We bypass
389 sending a new program signals list down to the target if the new
390 packet is exactly the same as the last we sent. IOW, we only let
391 the target know about program signals list changes. */
392 char *last_program_signals_packet
;
394 enum gdb_signal last_sent_signal
;
398 char *finished_object
;
399 char *finished_annex
;
400 ULONGEST finished_offset
;
402 /* Should we try the 'ThreadInfo' query packet?
404 This variable (NOT available to the user: auto-detect only!)
405 determines whether GDB will use the new, simpler "ThreadInfo"
406 query or the older, more complex syntax for thread queries.
407 This is an auto-detect variable (set to true at each connect,
408 and set to false when the target fails to recognize it). */
409 int use_threadinfo_query
;
410 int use_threadextra_query
;
412 void (*async_client_callback
) (enum inferior_event_type event_type
,
414 void *async_client_context
;
416 /* This is set to the data address of the access causing the target
417 to stop for a watchpoint. */
418 CORE_ADDR remote_watch_data_address
;
420 /* This is non-zero if target stopped for a watchpoint. */
421 int remote_stopped_by_watchpoint_p
;
423 threadref echo_nextthread
;
424 threadref nextthread
;
425 threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
427 /* The state of remote notification. */
428 struct remote_notif_state
*notif_state
;
431 /* Private data that we'll store in (struct thread_info)->private. */
432 struct private_thread_info
439 free_private_thread_info (struct private_thread_info
*info
)
445 /* Returns true if the multi-process extensions are in effect. */
447 remote_multi_process_p (struct remote_state
*rs
)
449 return rs
->multi_process_aware
;
452 /* This data could be associated with a target, but we do not always
453 have access to the current target when we need it, so for now it is
454 static. This will be fine for as long as only one target is in use
456 static struct remote_state
*remote_state
;
458 static struct remote_state
*
459 get_remote_state_raw (void)
464 /* Allocate a new struct remote_state with xmalloc, initialize it, and
467 static struct remote_state
*
468 new_remote_state (void)
470 struct remote_state
*result
= XCNEW (struct remote_state
);
472 /* The default buffer size is unimportant; it will be expanded
473 whenever a larger buffer is needed. */
474 result
->buf_size
= 400;
475 result
->buf
= xmalloc (result
->buf_size
);
476 result
->remote_traceframe_number
= -1;
477 result
->last_sent_signal
= GDB_SIGNAL_0
;
482 /* Description of the remote protocol for a given architecture. */
486 long offset
; /* Offset into G packet. */
487 long regnum
; /* GDB's internal register number. */
488 LONGEST pnum
; /* Remote protocol register number. */
489 int in_g_packet
; /* Always part of G packet. */
490 /* long size in bytes; == register_size (target_gdbarch (), regnum);
492 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
496 struct remote_arch_state
498 /* Description of the remote protocol registers. */
499 long sizeof_g_packet
;
501 /* Description of the remote protocol registers indexed by REGNUM
502 (making an array gdbarch_num_regs in size). */
503 struct packet_reg
*regs
;
505 /* This is the size (in chars) of the first response to the ``g''
506 packet. It is used as a heuristic when determining the maximum
507 size of memory-read and memory-write packets. A target will
508 typically only reserve a buffer large enough to hold the ``g''
509 packet. The size does not include packet overhead (headers and
511 long actual_register_packet_size
;
513 /* This is the maximum size (in chars) of a non read/write packet.
514 It is also used as a cap on the size of read/write packets. */
515 long remote_packet_size
;
518 /* Utility: generate error from an incoming stub packet. */
520 trace_error (char *buf
)
523 return; /* not an error msg */
526 case '1': /* malformed packet error */
527 if (*++buf
== '0') /* general case: */
528 error (_("remote.c: error in outgoing packet."));
530 error (_("remote.c: error in outgoing packet at field #%ld."),
531 strtol (buf
, NULL
, 16));
533 error (_("Target returns error code '%s'."), buf
);
537 /* Utility: wait for reply from stub, while accepting "O" packets. */
539 remote_get_noisy_reply (char **buf_p
,
542 do /* Loop on reply from remote stub. */
546 QUIT
; /* Allow user to bail out with ^C. */
547 getpkt (buf_p
, sizeof_buf
, 0);
551 else if (strncmp (buf
, "qRelocInsn:", strlen ("qRelocInsn:")) == 0)
554 CORE_ADDR from
, to
, org_to
;
556 int adjusted_size
= 0;
557 volatile struct gdb_exception ex
;
559 p
= buf
+ strlen ("qRelocInsn:");
560 pp
= unpack_varlen_hex (p
, &ul
);
562 error (_("invalid qRelocInsn packet: %s"), buf
);
566 unpack_varlen_hex (p
, &ul
);
571 TRY_CATCH (ex
, RETURN_MASK_ALL
)
573 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
577 adjusted_size
= to
- org_to
;
579 xsnprintf (buf
, *sizeof_buf
, "qRelocInsn:%x", adjusted_size
);
582 else if (ex
.reason
< 0 && ex
.error
== MEMORY_ERROR
)
584 /* Propagate memory errors silently back to the target.
585 The stub may have limited the range of addresses we
586 can write to, for example. */
591 /* Something unexpectedly bad happened. Be verbose so
592 we can tell what, and propagate the error back to the
593 stub, so it doesn't get stuck waiting for a
595 exception_fprintf (gdb_stderr
, ex
,
596 _("warning: relocating instruction: "));
600 else if (buf
[0] == 'O' && buf
[1] != 'K')
601 remote_console_output (buf
+ 1); /* 'O' message from stub */
603 return buf
; /* Here's the actual reply. */
608 /* Handle for retreving the remote protocol data from gdbarch. */
609 static struct gdbarch_data
*remote_gdbarch_data_handle
;
611 static struct remote_arch_state
*
612 get_remote_arch_state (void)
614 return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle
);
617 /* Fetch the global remote target state. */
619 static struct remote_state
*
620 get_remote_state (void)
622 /* Make sure that the remote architecture state has been
623 initialized, because doing so might reallocate rs->buf. Any
624 function which calls getpkt also needs to be mindful of changes
625 to rs->buf, but this call limits the number of places which run
627 get_remote_arch_state ();
629 return get_remote_state_raw ();
633 compare_pnums (const void *lhs_
, const void *rhs_
)
635 const struct packet_reg
* const *lhs
= lhs_
;
636 const struct packet_reg
* const *rhs
= rhs_
;
638 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
640 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
647 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
649 int regnum
, num_remote_regs
, offset
;
650 struct packet_reg
**remote_regs
;
652 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
654 struct packet_reg
*r
= ®s
[regnum
];
656 if (register_size (gdbarch
, regnum
) == 0)
657 /* Do not try to fetch zero-sized (placeholder) registers. */
660 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
665 /* Define the g/G packet format as the contents of each register
666 with a remote protocol number, in order of ascending protocol
669 remote_regs
= alloca (gdbarch_num_regs (gdbarch
)
670 * sizeof (struct packet_reg
*));
671 for (num_remote_regs
= 0, regnum
= 0;
672 regnum
< gdbarch_num_regs (gdbarch
);
674 if (regs
[regnum
].pnum
!= -1)
675 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
677 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
680 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
682 remote_regs
[regnum
]->in_g_packet
= 1;
683 remote_regs
[regnum
]->offset
= offset
;
684 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
690 /* Given the architecture described by GDBARCH, return the remote
691 protocol register's number and the register's offset in the g/G
692 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
693 If the target does not have a mapping for REGNUM, return false,
694 otherwise, return true. */
697 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
698 int *pnum
, int *poffset
)
701 struct packet_reg
*regs
;
702 struct cleanup
*old_chain
;
704 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
706 regs
= xcalloc (gdbarch_num_regs (gdbarch
), sizeof (struct packet_reg
));
707 old_chain
= make_cleanup (xfree
, regs
);
709 sizeof_g_packet
= map_regcache_remote_table (gdbarch
, regs
);
711 *pnum
= regs
[regnum
].pnum
;
712 *poffset
= regs
[regnum
].offset
;
714 do_cleanups (old_chain
);
720 init_remote_state (struct gdbarch
*gdbarch
)
722 struct remote_state
*rs
= get_remote_state_raw ();
723 struct remote_arch_state
*rsa
;
725 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
727 /* Use the architecture to build a regnum<->pnum table, which will be
728 1:1 unless a feature set specifies otherwise. */
729 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
730 gdbarch_num_regs (gdbarch
),
733 /* Record the maximum possible size of the g packet - it may turn out
735 rsa
->sizeof_g_packet
= map_regcache_remote_table (gdbarch
, rsa
->regs
);
737 /* Default maximum number of characters in a packet body. Many
738 remote stubs have a hardwired buffer size of 400 bytes
739 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
740 as the maximum packet-size to ensure that the packet and an extra
741 NUL character can always fit in the buffer. This stops GDB
742 trashing stubs that try to squeeze an extra NUL into what is
743 already a full buffer (As of 1999-12-04 that was most stubs). */
744 rsa
->remote_packet_size
= 400 - 1;
746 /* This one is filled in when a ``g'' packet is received. */
747 rsa
->actual_register_packet_size
= 0;
749 /* Should rsa->sizeof_g_packet needs more space than the
750 default, adjust the size accordingly. Remember that each byte is
751 encoded as two characters. 32 is the overhead for the packet
752 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
753 (``$NN:G...#NN'') is a better guess, the below has been padded a
755 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
756 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
758 /* Make sure that the packet buffer is plenty big enough for
759 this architecture. */
760 if (rs
->buf_size
< rsa
->remote_packet_size
)
762 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
763 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
769 /* Return the current allowed size of a remote packet. This is
770 inferred from the current architecture, and should be used to
771 limit the length of outgoing packets. */
773 get_remote_packet_size (void)
775 struct remote_state
*rs
= get_remote_state ();
776 struct remote_arch_state
*rsa
= get_remote_arch_state ();
778 if (rs
->explicit_packet_size
)
779 return rs
->explicit_packet_size
;
781 return rsa
->remote_packet_size
;
784 static struct packet_reg
*
785 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
787 if (regnum
< 0 && regnum
>= gdbarch_num_regs (target_gdbarch ()))
791 struct packet_reg
*r
= &rsa
->regs
[regnum
];
793 gdb_assert (r
->regnum
== regnum
);
798 static struct packet_reg
*
799 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
803 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
805 struct packet_reg
*r
= &rsa
->regs
[i
];
813 static struct target_ops remote_ops
;
815 static struct target_ops extended_remote_ops
;
817 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
818 ``forever'' still use the normal timeout mechanism. This is
819 currently used by the ASYNC code to guarentee that target reads
820 during the initial connect always time-out. Once getpkt has been
821 modified to return a timeout indication and, in turn
822 remote_wait()/wait_for_inferior() have gained a timeout parameter
824 static int wait_forever_enabled_p
= 1;
826 /* Allow the user to specify what sequence to send to the remote
827 when he requests a program interruption: Although ^C is usually
828 what remote systems expect (this is the default, here), it is
829 sometimes preferable to send a break. On other systems such
830 as the Linux kernel, a break followed by g, which is Magic SysRq g
831 is required in order to interrupt the execution. */
832 const char interrupt_sequence_control_c
[] = "Ctrl-C";
833 const char interrupt_sequence_break
[] = "BREAK";
834 const char interrupt_sequence_break_g
[] = "BREAK-g";
835 static const char *const interrupt_sequence_modes
[] =
837 interrupt_sequence_control_c
,
838 interrupt_sequence_break
,
839 interrupt_sequence_break_g
,
842 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
845 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
846 struct cmd_list_element
*c
,
849 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
850 fprintf_filtered (file
,
851 _("Send the ASCII ETX character (Ctrl-c) "
852 "to the remote target to interrupt the "
853 "execution of the program.\n"));
854 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
855 fprintf_filtered (file
,
856 _("send a break signal to the remote target "
857 "to interrupt the execution of the program.\n"));
858 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
859 fprintf_filtered (file
,
860 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
861 "the remote target to interrupt the execution "
862 "of Linux kernel.\n"));
864 internal_error (__FILE__
, __LINE__
,
865 _("Invalid value for interrupt_sequence_mode: %s."),
866 interrupt_sequence_mode
);
869 /* This boolean variable specifies whether interrupt_sequence is sent
870 to the remote target when gdb connects to it.
871 This is mostly needed when you debug the Linux kernel: The Linux kernel
872 expects BREAK g which is Magic SysRq g for connecting gdb. */
873 static int interrupt_on_connect
= 0;
875 /* This variable is used to implement the "set/show remotebreak" commands.
876 Since these commands are now deprecated in favor of "set/show remote
877 interrupt-sequence", it no longer has any effect on the code. */
878 static int remote_break
;
881 set_remotebreak (char *args
, int from_tty
, struct cmd_list_element
*c
)
884 interrupt_sequence_mode
= interrupt_sequence_break
;
886 interrupt_sequence_mode
= interrupt_sequence_control_c
;
890 show_remotebreak (struct ui_file
*file
, int from_tty
,
891 struct cmd_list_element
*c
,
896 /* This variable sets the number of bits in an address that are to be
897 sent in a memory ("M" or "m") packet. Normally, after stripping
898 leading zeros, the entire address would be sent. This variable
899 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
900 initial implementation of remote.c restricted the address sent in
901 memory packets to ``host::sizeof long'' bytes - (typically 32
902 bits). Consequently, for 64 bit targets, the upper 32 bits of an
903 address was never sent. Since fixing this bug may cause a break in
904 some remote targets this variable is principly provided to
905 facilitate backward compatibility. */
907 static unsigned int remote_address_size
;
909 /* Temporary to track who currently owns the terminal. See
910 remote_terminal_* for more details. */
912 static int remote_async_terminal_ours_p
;
914 /* The executable file to use for "run" on the remote side. */
916 static char *remote_exec_file
= "";
919 /* User configurable variables for the number of characters in a
920 memory read/write packet. MIN (rsa->remote_packet_size,
921 rsa->sizeof_g_packet) is the default. Some targets need smaller
922 values (fifo overruns, et.al.) and some users need larger values
923 (speed up transfers). The variables ``preferred_*'' (the user
924 request), ``current_*'' (what was actually set) and ``forced_*''
925 (Positive - a soft limit, negative - a hard limit). */
927 struct memory_packet_config
934 /* Compute the current size of a read/write packet. Since this makes
935 use of ``actual_register_packet_size'' the computation is dynamic. */
938 get_memory_packet_size (struct memory_packet_config
*config
)
940 struct remote_state
*rs
= get_remote_state ();
941 struct remote_arch_state
*rsa
= get_remote_arch_state ();
943 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
944 law?) that some hosts don't cope very well with large alloca()
945 calls. Eventually the alloca() code will be replaced by calls to
946 xmalloc() and make_cleanups() allowing this restriction to either
947 be lifted or removed. */
948 #ifndef MAX_REMOTE_PACKET_SIZE
949 #define MAX_REMOTE_PACKET_SIZE 16384
951 /* NOTE: 20 ensures we can write at least one byte. */
952 #ifndef MIN_REMOTE_PACKET_SIZE
953 #define MIN_REMOTE_PACKET_SIZE 20
958 if (config
->size
<= 0)
959 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
961 what_they_get
= config
->size
;
965 what_they_get
= get_remote_packet_size ();
966 /* Limit the packet to the size specified by the user. */
968 && what_they_get
> config
->size
)
969 what_they_get
= config
->size
;
971 /* Limit it to the size of the targets ``g'' response unless we have
972 permission from the stub to use a larger packet size. */
973 if (rs
->explicit_packet_size
== 0
974 && rsa
->actual_register_packet_size
> 0
975 && what_they_get
> rsa
->actual_register_packet_size
)
976 what_they_get
= rsa
->actual_register_packet_size
;
978 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
979 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
980 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
981 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
983 /* Make sure there is room in the global buffer for this packet
984 (including its trailing NUL byte). */
985 if (rs
->buf_size
< what_they_get
+ 1)
987 rs
->buf_size
= 2 * what_they_get
;
988 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
991 return what_they_get
;
994 /* Update the size of a read/write packet. If they user wants
995 something really big then do a sanity check. */
998 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
1000 int fixed_p
= config
->fixed_p
;
1001 long size
= config
->size
;
1004 error (_("Argument required (integer, `fixed' or `limited')."));
1005 else if (strcmp (args
, "hard") == 0
1006 || strcmp (args
, "fixed") == 0)
1008 else if (strcmp (args
, "soft") == 0
1009 || strcmp (args
, "limit") == 0)
1015 size
= strtoul (args
, &end
, 0);
1017 error (_("Invalid %s (bad syntax)."), config
->name
);
1019 /* Instead of explicitly capping the size of a packet to
1020 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
1021 instead allowed to set the size to something arbitrarily
1023 if (size
> MAX_REMOTE_PACKET_SIZE
)
1024 error (_("Invalid %s (too large)."), config
->name
);
1028 if (fixed_p
&& !config
->fixed_p
)
1030 if (! query (_("The target may not be able to correctly handle a %s\n"
1031 "of %ld bytes. Change the packet size? "),
1032 config
->name
, size
))
1033 error (_("Packet size not changed."));
1035 /* Update the config. */
1036 config
->fixed_p
= fixed_p
;
1037 config
->size
= size
;
1041 show_memory_packet_size (struct memory_packet_config
*config
)
1043 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1044 if (config
->fixed_p
)
1045 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1046 get_memory_packet_size (config
));
1048 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1049 get_memory_packet_size (config
));
1052 static struct memory_packet_config memory_write_packet_config
=
1054 "memory-write-packet-size",
1058 set_memory_write_packet_size (char *args
, int from_tty
)
1060 set_memory_packet_size (args
, &memory_write_packet_config
);
1064 show_memory_write_packet_size (char *args
, int from_tty
)
1066 show_memory_packet_size (&memory_write_packet_config
);
1070 get_memory_write_packet_size (void)
1072 return get_memory_packet_size (&memory_write_packet_config
);
1075 static struct memory_packet_config memory_read_packet_config
=
1077 "memory-read-packet-size",
1081 set_memory_read_packet_size (char *args
, int from_tty
)
1083 set_memory_packet_size (args
, &memory_read_packet_config
);
1087 show_memory_read_packet_size (char *args
, int from_tty
)
1089 show_memory_packet_size (&memory_read_packet_config
);
1093 get_memory_read_packet_size (void)
1095 long size
= get_memory_packet_size (&memory_read_packet_config
);
1097 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1098 extra buffer size argument before the memory read size can be
1099 increased beyond this. */
1100 if (size
> get_remote_packet_size ())
1101 size
= get_remote_packet_size ();
1106 /* Generic configuration support for packets the stub optionally
1107 supports. Allows the user to specify the use of the packet as well
1108 as allowing GDB to auto-detect support in the remote stub. */
1112 PACKET_SUPPORT_UNKNOWN
= 0,
1117 struct packet_config
1121 enum auto_boolean detect
;
1122 enum packet_support support
;
1125 /* Analyze a packet's return value and update the packet config
1136 update_packet_config (struct packet_config
*config
)
1138 switch (config
->detect
)
1140 case AUTO_BOOLEAN_TRUE
:
1141 config
->support
= PACKET_ENABLE
;
1143 case AUTO_BOOLEAN_FALSE
:
1144 config
->support
= PACKET_DISABLE
;
1146 case AUTO_BOOLEAN_AUTO
:
1147 config
->support
= PACKET_SUPPORT_UNKNOWN
;
1153 show_packet_config_cmd (struct packet_config
*config
)
1155 char *support
= "internal-error";
1157 switch (config
->support
)
1160 support
= "enabled";
1162 case PACKET_DISABLE
:
1163 support
= "disabled";
1165 case PACKET_SUPPORT_UNKNOWN
:
1166 support
= "unknown";
1169 switch (config
->detect
)
1171 case AUTO_BOOLEAN_AUTO
:
1172 printf_filtered (_("Support for the `%s' packet "
1173 "is auto-detected, currently %s.\n"),
1174 config
->name
, support
);
1176 case AUTO_BOOLEAN_TRUE
:
1177 case AUTO_BOOLEAN_FALSE
:
1178 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1179 config
->name
, support
);
1185 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1186 const char *title
, int legacy
)
1192 config
->name
= name
;
1193 config
->title
= title
;
1194 config
->detect
= AUTO_BOOLEAN_AUTO
;
1195 config
->support
= PACKET_SUPPORT_UNKNOWN
;
1196 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1198 show_doc
= xstrprintf ("Show current use of remote "
1199 "protocol `%s' (%s) packet",
1201 /* set/show TITLE-packet {auto,on,off} */
1202 cmd_name
= xstrprintf ("%s-packet", title
);
1203 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1204 &config
->detect
, set_doc
,
1205 show_doc
, NULL
, /* help_doc */
1206 set_remote_protocol_packet_cmd
,
1207 show_remote_protocol_packet_cmd
,
1208 &remote_set_cmdlist
, &remote_show_cmdlist
);
1209 /* The command code copies the documentation strings. */
1212 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1217 legacy_name
= xstrprintf ("%s-packet", name
);
1218 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1219 &remote_set_cmdlist
);
1220 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1221 &remote_show_cmdlist
);
1225 static enum packet_result
1226 packet_check_result (const char *buf
)
1230 /* The stub recognized the packet request. Check that the
1231 operation succeeded. */
1233 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1235 /* "Enn" - definitly an error. */
1236 return PACKET_ERROR
;
1238 /* Always treat "E." as an error. This will be used for
1239 more verbose error messages, such as E.memtypes. */
1240 if (buf
[0] == 'E' && buf
[1] == '.')
1241 return PACKET_ERROR
;
1243 /* The packet may or may not be OK. Just assume it is. */
1247 /* The stub does not support the packet. */
1248 return PACKET_UNKNOWN
;
1251 static enum packet_result
1252 packet_ok (const char *buf
, struct packet_config
*config
)
1254 enum packet_result result
;
1256 result
= packet_check_result (buf
);
1261 /* The stub recognized the packet request. */
1262 switch (config
->support
)
1264 case PACKET_SUPPORT_UNKNOWN
:
1266 fprintf_unfiltered (gdb_stdlog
,
1267 "Packet %s (%s) is supported\n",
1268 config
->name
, config
->title
);
1269 config
->support
= PACKET_ENABLE
;
1271 case PACKET_DISABLE
:
1272 internal_error (__FILE__
, __LINE__
,
1273 _("packet_ok: attempt to use a disabled packet"));
1279 case PACKET_UNKNOWN
:
1280 /* The stub does not support the packet. */
1281 switch (config
->support
)
1284 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
1285 /* If the stub previously indicated that the packet was
1286 supported then there is a protocol error.. */
1287 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1288 config
->name
, config
->title
);
1290 /* The user set it wrong. */
1291 error (_("Enabled packet %s (%s) not recognized by stub"),
1292 config
->name
, config
->title
);
1294 case PACKET_SUPPORT_UNKNOWN
:
1296 fprintf_unfiltered (gdb_stdlog
,
1297 "Packet %s (%s) is NOT supported\n",
1298 config
->name
, config
->title
);
1299 config
->support
= PACKET_DISABLE
;
1301 case PACKET_DISABLE
:
1323 PACKET_vFile_pwrite
,
1325 PACKET_vFile_unlink
,
1326 PACKET_vFile_readlink
,
1328 PACKET_qXfer_features
,
1329 PACKET_qXfer_libraries
,
1330 PACKET_qXfer_libraries_svr4
,
1331 PACKET_qXfer_memory_map
,
1332 PACKET_qXfer_spu_read
,
1333 PACKET_qXfer_spu_write
,
1334 PACKET_qXfer_osdata
,
1335 PACKET_qXfer_threads
,
1336 PACKET_qXfer_statictrace_read
,
1337 PACKET_qXfer_traceframe_info
,
1343 PACKET_QPassSignals
,
1344 PACKET_QProgramSignals
,
1345 PACKET_qSearch_memory
,
1348 PACKET_QStartNoAckMode
,
1350 PACKET_qXfer_siginfo_read
,
1351 PACKET_qXfer_siginfo_write
,
1353 PACKET_ConditionalTracepoints
,
1354 PACKET_ConditionalBreakpoints
,
1355 PACKET_BreakpointCommands
,
1356 PACKET_FastTracepoints
,
1357 PACKET_StaticTracepoints
,
1358 PACKET_InstallInTrace
,
1361 PACKET_TracepointSource
,
1364 PACKET_QDisableRandomization
,
1366 PACKET_QTBuffer_size
,
1369 PACKET_qXfer_btrace
,
1373 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
1376 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
1377 struct cmd_list_element
*c
)
1379 struct packet_config
*packet
;
1381 for (packet
= remote_protocol_packets
;
1382 packet
< &remote_protocol_packets
[PACKET_MAX
];
1385 if (&packet
->detect
== c
->var
)
1387 update_packet_config (packet
);
1391 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
1396 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
1397 struct cmd_list_element
*c
,
1400 struct packet_config
*packet
;
1402 for (packet
= remote_protocol_packets
;
1403 packet
< &remote_protocol_packets
[PACKET_MAX
];
1406 if (&packet
->detect
== c
->var
)
1408 show_packet_config_cmd (packet
);
1412 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
1416 /* Should we try one of the 'Z' requests? */
1420 Z_PACKET_SOFTWARE_BP
,
1421 Z_PACKET_HARDWARE_BP
,
1428 /* For compatibility with older distributions. Provide a ``set remote
1429 Z-packet ...'' command that updates all the Z packet types. */
1431 static enum auto_boolean remote_Z_packet_detect
;
1434 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1435 struct cmd_list_element
*c
)
1439 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1441 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1442 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1447 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1448 struct cmd_list_element
*c
,
1453 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1455 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1459 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1460 static struct async_signal_handler
*async_sigint_remote_twice_token
;
1461 static struct async_signal_handler
*async_sigint_remote_token
;
1464 /* Asynchronous signal handle registered as event loop source for
1465 when we have pending events ready to be passed to the core. */
1467 static struct async_event_handler
*remote_async_inferior_event_token
;
1471 static ptid_t magic_null_ptid
;
1472 static ptid_t not_sent_ptid
;
1473 static ptid_t any_thread_ptid
;
1475 /* Find out if the stub attached to PID (and hence GDB should offer to
1476 detach instead of killing it when bailing out). */
1479 remote_query_attached (int pid
)
1481 struct remote_state
*rs
= get_remote_state ();
1482 size_t size
= get_remote_packet_size ();
1484 if (remote_protocol_packets
[PACKET_qAttached
].support
== PACKET_DISABLE
)
1487 if (remote_multi_process_p (rs
))
1488 xsnprintf (rs
->buf
, size
, "qAttached:%x", pid
);
1490 xsnprintf (rs
->buf
, size
, "qAttached");
1493 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1495 switch (packet_ok (rs
->buf
,
1496 &remote_protocol_packets
[PACKET_qAttached
]))
1499 if (strcmp (rs
->buf
, "1") == 0)
1503 warning (_("Remote failure reply: %s"), rs
->buf
);
1505 case PACKET_UNKNOWN
:
1512 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1513 has been invented by GDB, instead of reported by the target. Since
1514 we can be connected to a remote system before before knowing about
1515 any inferior, mark the target with execution when we find the first
1516 inferior. If ATTACHED is 1, then we had just attached to this
1517 inferior. If it is 0, then we just created this inferior. If it
1518 is -1, then try querying the remote stub to find out if it had
1519 attached to the inferior or not. */
1521 static struct inferior
*
1522 remote_add_inferior (int fake_pid_p
, int pid
, int attached
)
1524 struct inferior
*inf
;
1526 /* Check whether this process we're learning about is to be
1527 considered attached, or if is to be considered to have been
1528 spawned by the stub. */
1530 attached
= remote_query_attached (pid
);
1532 if (gdbarch_has_global_solist (target_gdbarch ()))
1534 /* If the target shares code across all inferiors, then every
1535 attach adds a new inferior. */
1536 inf
= add_inferior (pid
);
1538 /* ... and every inferior is bound to the same program space.
1539 However, each inferior may still have its own address
1541 inf
->aspace
= maybe_new_address_space ();
1542 inf
->pspace
= current_program_space
;
1546 /* In the traditional debugging scenario, there's a 1-1 match
1547 between program/address spaces. We simply bind the inferior
1548 to the program space's address space. */
1549 inf
= current_inferior ();
1550 inferior_appeared (inf
, pid
);
1553 inf
->attach_flag
= attached
;
1554 inf
->fake_pid_p
= fake_pid_p
;
1559 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1560 according to RUNNING. */
1563 remote_add_thread (ptid_t ptid
, int running
)
1565 struct remote_state
*rs
= get_remote_state ();
1567 /* GDB historically didn't pull threads in the initial connection
1568 setup. If the remote target doesn't even have a concept of
1569 threads (e.g., a bare-metal target), even if internally we
1570 consider that a single-threaded target, mentioning a new thread
1571 might be confusing to the user. Be silent then, preserving the
1572 age old behavior. */
1573 if (rs
->starting_up
)
1574 add_thread_silent (ptid
);
1578 set_executing (ptid
, running
);
1579 set_running (ptid
, running
);
1582 /* Come here when we learn about a thread id from the remote target.
1583 It may be the first time we hear about such thread, so take the
1584 opportunity to add it to GDB's thread list. In case this is the
1585 first time we're noticing its corresponding inferior, add it to
1586 GDB's inferior list as well. */
1589 remote_notice_new_inferior (ptid_t currthread
, int running
)
1591 /* If this is a new thread, add it to GDB's thread list.
1592 If we leave it up to WFI to do this, bad things will happen. */
1594 if (in_thread_list (currthread
) && is_exited (currthread
))
1596 /* We're seeing an event on a thread id we knew had exited.
1597 This has to be a new thread reusing the old id. Add it. */
1598 remote_add_thread (currthread
, running
);
1602 if (!in_thread_list (currthread
))
1604 struct inferior
*inf
= NULL
;
1605 int pid
= ptid_get_pid (currthread
);
1607 if (ptid_is_pid (inferior_ptid
)
1608 && pid
== ptid_get_pid (inferior_ptid
))
1610 /* inferior_ptid has no thread member yet. This can happen
1611 with the vAttach -> remote_wait,"TAAthread:" path if the
1612 stub doesn't support qC. This is the first stop reported
1613 after an attach, so this is the main thread. Update the
1614 ptid in the thread list. */
1615 if (in_thread_list (pid_to_ptid (pid
)))
1616 thread_change_ptid (inferior_ptid
, currthread
);
1619 remote_add_thread (currthread
, running
);
1620 inferior_ptid
= currthread
;
1625 if (ptid_equal (magic_null_ptid
, inferior_ptid
))
1627 /* inferior_ptid is not set yet. This can happen with the
1628 vRun -> remote_wait,"TAAthread:" path if the stub
1629 doesn't support qC. This is the first stop reported
1630 after an attach, so this is the main thread. Update the
1631 ptid in the thread list. */
1632 thread_change_ptid (inferior_ptid
, currthread
);
1636 /* When connecting to a target remote, or to a target
1637 extended-remote which already was debugging an inferior, we
1638 may not know about it yet. Add it before adding its child
1639 thread, so notifications are emitted in a sensible order. */
1640 if (!in_inferior_list (ptid_get_pid (currthread
)))
1642 struct remote_state
*rs
= get_remote_state ();
1643 int fake_pid_p
= !remote_multi_process_p (rs
);
1645 inf
= remote_add_inferior (fake_pid_p
,
1646 ptid_get_pid (currthread
), -1);
1649 /* This is really a new thread. Add it. */
1650 remote_add_thread (currthread
, running
);
1652 /* If we found a new inferior, let the common code do whatever
1653 it needs to with it (e.g., read shared libraries, insert
1654 breakpoints), unless we're just setting up an all-stop
1658 struct remote_state
*rs
= get_remote_state ();
1660 if (non_stop
|| !rs
->starting_up
)
1661 notice_new_inferior (currthread
, running
, 0);
1666 /* Return the private thread data, creating it if necessary. */
1668 static struct private_thread_info
*
1669 demand_private_info (ptid_t ptid
)
1671 struct thread_info
*info
= find_thread_ptid (ptid
);
1677 info
->private = xmalloc (sizeof (*(info
->private)));
1678 info
->private_dtor
= free_private_thread_info
;
1679 info
->private->core
= -1;
1680 info
->private->extra
= 0;
1683 return info
->private;
1686 /* Call this function as a result of
1687 1) A halt indication (T packet) containing a thread id
1688 2) A direct query of currthread
1689 3) Successful execution of set thread */
1692 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
1694 rs
->general_thread
= currthread
;
1697 /* If 'QPassSignals' is supported, tell the remote stub what signals
1698 it can simply pass through to the inferior without reporting. */
1701 remote_pass_signals (int numsigs
, unsigned char *pass_signals
)
1703 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1705 char *pass_packet
, *p
;
1707 struct remote_state
*rs
= get_remote_state ();
1709 gdb_assert (numsigs
< 256);
1710 for (i
= 0; i
< numsigs
; i
++)
1712 if (pass_signals
[i
])
1715 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1716 strcpy (pass_packet
, "QPassSignals:");
1717 p
= pass_packet
+ strlen (pass_packet
);
1718 for (i
= 0; i
< numsigs
; i
++)
1720 if (pass_signals
[i
])
1723 *p
++ = tohex (i
>> 4);
1724 *p
++ = tohex (i
& 15);
1733 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
1735 char *buf
= rs
->buf
;
1737 putpkt (pass_packet
);
1738 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1739 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1740 if (rs
->last_pass_packet
)
1741 xfree (rs
->last_pass_packet
);
1742 rs
->last_pass_packet
= pass_packet
;
1745 xfree (pass_packet
);
1749 /* If 'QProgramSignals' is supported, tell the remote stub what
1750 signals it should pass through to the inferior when detaching. */
1753 remote_program_signals (int numsigs
, unsigned char *signals
)
1755 if (remote_protocol_packets
[PACKET_QProgramSignals
].support
!= PACKET_DISABLE
)
1759 struct remote_state
*rs
= get_remote_state ();
1761 gdb_assert (numsigs
< 256);
1762 for (i
= 0; i
< numsigs
; i
++)
1767 packet
= xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
1768 strcpy (packet
, "QProgramSignals:");
1769 p
= packet
+ strlen (packet
);
1770 for (i
= 0; i
< numsigs
; i
++)
1772 if (signal_pass_state (i
))
1775 *p
++ = tohex (i
>> 4);
1776 *p
++ = tohex (i
& 15);
1785 if (!rs
->last_program_signals_packet
1786 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
1788 char *buf
= rs
->buf
;
1791 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1792 packet_ok (buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
1793 xfree (rs
->last_program_signals_packet
);
1794 rs
->last_program_signals_packet
= packet
;
1801 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
1802 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1803 thread. If GEN is set, set the general thread, if not, then set
1804 the step/continue thread. */
1806 set_thread (struct ptid ptid
, int gen
)
1808 struct remote_state
*rs
= get_remote_state ();
1809 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
1810 char *buf
= rs
->buf
;
1811 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
1813 if (ptid_equal (state
, ptid
))
1817 *buf
++ = gen
? 'g' : 'c';
1818 if (ptid_equal (ptid
, magic_null_ptid
))
1819 xsnprintf (buf
, endbuf
- buf
, "0");
1820 else if (ptid_equal (ptid
, any_thread_ptid
))
1821 xsnprintf (buf
, endbuf
- buf
, "0");
1822 else if (ptid_equal (ptid
, minus_one_ptid
))
1823 xsnprintf (buf
, endbuf
- buf
, "-1");
1825 write_ptid (buf
, endbuf
, ptid
);
1827 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1829 rs
->general_thread
= ptid
;
1831 rs
->continue_thread
= ptid
;
1835 set_general_thread (struct ptid ptid
)
1837 set_thread (ptid
, 1);
1841 set_continue_thread (struct ptid ptid
)
1843 set_thread (ptid
, 0);
1846 /* Change the remote current process. Which thread within the process
1847 ends up selected isn't important, as long as it is the same process
1848 as what INFERIOR_PTID points to.
1850 This comes from that fact that there is no explicit notion of
1851 "selected process" in the protocol. The selected process for
1852 general operations is the process the selected general thread
1856 set_general_process (void)
1858 struct remote_state
*rs
= get_remote_state ();
1860 /* If the remote can't handle multiple processes, don't bother. */
1861 if (!rs
->extended
|| !remote_multi_process_p (rs
))
1864 /* We only need to change the remote current thread if it's pointing
1865 at some other process. */
1866 if (ptid_get_pid (rs
->general_thread
) != ptid_get_pid (inferior_ptid
))
1867 set_general_thread (inferior_ptid
);
1871 /* Return nonzero if the thread PTID is still alive on the remote
1875 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1877 struct remote_state
*rs
= get_remote_state ();
1880 if (ptid_equal (ptid
, magic_null_ptid
))
1881 /* The main thread is always alive. */
1884 if (ptid_get_pid (ptid
) != 0 && ptid_get_tid (ptid
) == 0)
1885 /* The main thread is always alive. This can happen after a
1886 vAttach, if the remote side doesn't support
1891 endp
= rs
->buf
+ get_remote_packet_size ();
1894 write_ptid (p
, endp
, ptid
);
1897 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1898 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1901 /* About these extended threadlist and threadinfo packets. They are
1902 variable length packets but, the fields within them are often fixed
1903 length. They are redundent enough to send over UDP as is the
1904 remote protocol in general. There is a matching unit test module
1907 /* WARNING: This threadref data structure comes from the remote O.S.,
1908 libstub protocol encoding, and remote.c. It is not particularly
1911 /* Right now, the internal structure is int. We want it to be bigger.
1912 Plan to fix this. */
1914 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1916 /* gdb_ext_thread_info is an internal GDB data structure which is
1917 equivalent to the reply of the remote threadinfo packet. */
1919 struct gdb_ext_thread_info
1921 threadref threadid
; /* External form of thread reference. */
1922 int active
; /* Has state interesting to GDB?
1924 char display
[256]; /* Brief state display, name,
1925 blocked/suspended. */
1926 char shortname
[32]; /* To be used to name threads. */
1927 char more_display
[256]; /* Long info, statistics, queue depth,
1931 /* The volume of remote transfers can be limited by submitting
1932 a mask containing bits specifying the desired information.
1933 Use a union of these values as the 'selection' parameter to
1934 get_thread_info. FIXME: Make these TAG names more thread specific. */
1936 #define TAG_THREADID 1
1937 #define TAG_EXISTS 2
1938 #define TAG_DISPLAY 4
1939 #define TAG_THREADNAME 8
1940 #define TAG_MOREDISPLAY 16
1942 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1944 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1946 static char *unpack_nibble (char *buf
, int *val
);
1948 static char *pack_nibble (char *buf
, int nibble
);
1950 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1952 static char *unpack_byte (char *buf
, int *value
);
1954 static char *pack_int (char *buf
, int value
);
1956 static char *unpack_int (char *buf
, int *value
);
1958 static char *unpack_string (char *src
, char *dest
, int length
);
1960 static char *pack_threadid (char *pkt
, threadref
*id
);
1962 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1964 void int_to_threadref (threadref
*id
, int value
);
1966 static int threadref_to_int (threadref
*ref
);
1968 static void copy_threadref (threadref
*dest
, threadref
*src
);
1970 static int threadmatch (threadref
*dest
, threadref
*src
);
1972 static char *pack_threadinfo_request (char *pkt
, int mode
,
1975 static int remote_unpack_thread_info_response (char *pkt
,
1976 threadref
*expectedref
,
1977 struct gdb_ext_thread_info
1981 static int remote_get_threadinfo (threadref
*threadid
,
1982 int fieldset
, /*TAG mask */
1983 struct gdb_ext_thread_info
*info
);
1985 static char *pack_threadlist_request (char *pkt
, int startflag
,
1987 threadref
*nextthread
);
1989 static int parse_threadlist_response (char *pkt
,
1991 threadref
*original_echo
,
1992 threadref
*resultlist
,
1995 static int remote_get_threadlist (int startflag
,
1996 threadref
*nextthread
,
2000 threadref
*threadlist
);
2002 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
2004 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
2005 void *context
, int looplimit
);
2007 static int remote_newthread_step (threadref
*ref
, void *context
);
2010 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2011 buffer we're allowed to write to. Returns
2012 BUF+CHARACTERS_WRITTEN. */
2015 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2018 struct remote_state
*rs
= get_remote_state ();
2020 if (remote_multi_process_p (rs
))
2022 pid
= ptid_get_pid (ptid
);
2024 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2026 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2028 tid
= ptid_get_tid (ptid
);
2030 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2032 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2037 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
2038 passed the last parsed char. Returns null_ptid on error. */
2041 read_ptid (char *buf
, char **obuf
)
2045 ULONGEST pid
= 0, tid
= 0;
2049 /* Multi-process ptid. */
2050 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2052 error (_("invalid remote ptid: %s"), p
);
2055 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2058 return ptid_build (pid
, 0, tid
);
2061 /* No multi-process. Just a tid. */
2062 pp
= unpack_varlen_hex (p
, &tid
);
2064 /* Since the stub is not sending a process id, then default to
2065 what's in inferior_ptid, unless it's null at this point. If so,
2066 then since there's no way to know the pid of the reported
2067 threads, use the magic number. */
2068 if (ptid_equal (inferior_ptid
, null_ptid
))
2069 pid
= ptid_get_pid (magic_null_ptid
);
2071 pid
= ptid_get_pid (inferior_ptid
);
2075 return ptid_build (pid
, 0, tid
);
2078 /* Encode 64 bits in 16 chars of hex. */
2080 static const char hexchars
[] = "0123456789abcdef";
2083 ishex (int ch
, int *val
)
2085 if ((ch
>= 'a') && (ch
<= 'f'))
2087 *val
= ch
- 'a' + 10;
2090 if ((ch
>= 'A') && (ch
<= 'F'))
2092 *val
= ch
- 'A' + 10;
2095 if ((ch
>= '0') && (ch
<= '9'))
2106 if (ch
>= 'a' && ch
<= 'f')
2107 return ch
- 'a' + 10;
2108 if (ch
>= '0' && ch
<= '9')
2110 if (ch
>= 'A' && ch
<= 'F')
2111 return ch
- 'A' + 10;
2116 stub_unpack_int (char *buff
, int fieldlength
)
2123 nibble
= stubhex (*buff
++);
2127 retval
= retval
<< 4;
2133 unpack_varlen_hex (char *buff
, /* packet to parse */
2137 ULONGEST retval
= 0;
2139 while (ishex (*buff
, &nibble
))
2142 retval
= retval
<< 4;
2143 retval
|= nibble
& 0x0f;
2150 unpack_nibble (char *buf
, int *val
)
2152 *val
= fromhex (*buf
++);
2157 pack_nibble (char *buf
, int nibble
)
2159 *buf
++ = hexchars
[(nibble
& 0x0f)];
2164 pack_hex_byte (char *pkt
, int byte
)
2166 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
2167 *pkt
++ = hexchars
[(byte
& 0xf)];
2172 unpack_byte (char *buf
, int *value
)
2174 *value
= stub_unpack_int (buf
, 2);
2179 pack_int (char *buf
, int value
)
2181 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
2182 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
2183 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
2184 buf
= pack_hex_byte (buf
, (value
& 0xff));
2189 unpack_int (char *buf
, int *value
)
2191 *value
= stub_unpack_int (buf
, 8);
2195 #if 0 /* Currently unused, uncomment when needed. */
2196 static char *pack_string (char *pkt
, char *string
);
2199 pack_string (char *pkt
, char *string
)
2204 len
= strlen (string
);
2206 len
= 200; /* Bigger than most GDB packets, junk??? */
2207 pkt
= pack_hex_byte (pkt
, len
);
2211 if ((ch
== '\0') || (ch
== '#'))
2212 ch
= '*'; /* Protect encapsulation. */
2217 #endif /* 0 (unused) */
2220 unpack_string (char *src
, char *dest
, int length
)
2229 pack_threadid (char *pkt
, threadref
*id
)
2232 unsigned char *altid
;
2234 altid
= (unsigned char *) id
;
2235 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
2237 pkt
= pack_hex_byte (pkt
, *altid
++);
2243 unpack_threadid (char *inbuf
, threadref
*id
)
2246 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2249 altref
= (char *) id
;
2251 while (inbuf
< limit
)
2253 x
= stubhex (*inbuf
++);
2254 y
= stubhex (*inbuf
++);
2255 *altref
++ = (x
<< 4) | y
;
2260 /* Externally, threadrefs are 64 bits but internally, they are still
2261 ints. This is due to a mismatch of specifications. We would like
2262 to use 64bit thread references internally. This is an adapter
2266 int_to_threadref (threadref
*id
, int value
)
2268 unsigned char *scan
;
2270 scan
= (unsigned char *) id
;
2276 *scan
++ = (value
>> 24) & 0xff;
2277 *scan
++ = (value
>> 16) & 0xff;
2278 *scan
++ = (value
>> 8) & 0xff;
2279 *scan
++ = (value
& 0xff);
2283 threadref_to_int (threadref
*ref
)
2286 unsigned char *scan
;
2292 value
= (value
<< 8) | ((*scan
++) & 0xff);
2297 copy_threadref (threadref
*dest
, threadref
*src
)
2300 unsigned char *csrc
, *cdest
;
2302 csrc
= (unsigned char *) src
;
2303 cdest
= (unsigned char *) dest
;
2310 threadmatch (threadref
*dest
, threadref
*src
)
2312 /* Things are broken right now, so just assume we got a match. */
2314 unsigned char *srcp
, *destp
;
2316 srcp
= (char *) src
;
2317 destp
= (char *) dest
;
2321 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2328 threadid:1, # always request threadid
2335 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2338 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2340 *pkt
++ = 'q'; /* Info Query */
2341 *pkt
++ = 'P'; /* process or thread info */
2342 pkt
= pack_int (pkt
, mode
); /* mode */
2343 pkt
= pack_threadid (pkt
, id
); /* threadid */
2344 *pkt
= '\0'; /* terminate */
2348 /* These values tag the fields in a thread info response packet. */
2349 /* Tagging the fields allows us to request specific fields and to
2350 add more fields as time goes by. */
2352 #define TAG_THREADID 1 /* Echo the thread identifier. */
2353 #define TAG_EXISTS 2 /* Is this process defined enough to
2354 fetch registers and its stack? */
2355 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2356 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2357 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2361 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2362 struct gdb_ext_thread_info
*info
)
2364 struct remote_state
*rs
= get_remote_state ();
2368 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2371 /* info->threadid = 0; FIXME: implement zero_threadref. */
2373 info
->display
[0] = '\0';
2374 info
->shortname
[0] = '\0';
2375 info
->more_display
[0] = '\0';
2377 /* Assume the characters indicating the packet type have been
2379 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2380 pkt
= unpack_threadid (pkt
, &ref
);
2383 warning (_("Incomplete response to threadinfo request."));
2384 if (!threadmatch (&ref
, expectedref
))
2385 { /* This is an answer to a different request. */
2386 warning (_("ERROR RMT Thread info mismatch."));
2389 copy_threadref (&info
->threadid
, &ref
);
2391 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2393 /* Packets are terminated with nulls. */
2394 while ((pkt
< limit
) && mask
&& *pkt
)
2396 pkt
= unpack_int (pkt
, &tag
); /* tag */
2397 pkt
= unpack_byte (pkt
, &length
); /* length */
2398 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2400 warning (_("ERROR RMT: threadinfo tag mismatch."));
2404 if (tag
== TAG_THREADID
)
2408 warning (_("ERROR RMT: length of threadid is not 16."));
2412 pkt
= unpack_threadid (pkt
, &ref
);
2413 mask
= mask
& ~TAG_THREADID
;
2416 if (tag
== TAG_EXISTS
)
2418 info
->active
= stub_unpack_int (pkt
, length
);
2420 mask
= mask
& ~(TAG_EXISTS
);
2423 warning (_("ERROR RMT: 'exists' length too long."));
2429 if (tag
== TAG_THREADNAME
)
2431 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2432 mask
= mask
& ~TAG_THREADNAME
;
2435 if (tag
== TAG_DISPLAY
)
2437 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2438 mask
= mask
& ~TAG_DISPLAY
;
2441 if (tag
== TAG_MOREDISPLAY
)
2443 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2444 mask
= mask
& ~TAG_MOREDISPLAY
;
2447 warning (_("ERROR RMT: unknown thread info tag."));
2448 break; /* Not a tag we know about. */
2454 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2455 struct gdb_ext_thread_info
*info
)
2457 struct remote_state
*rs
= get_remote_state ();
2460 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2462 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2464 if (rs
->buf
[0] == '\0')
2467 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2472 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2475 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2476 threadref
*nextthread
)
2478 *pkt
++ = 'q'; /* info query packet */
2479 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2480 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2481 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2482 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2487 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2490 parse_threadlist_response (char *pkt
, int result_limit
,
2491 threadref
*original_echo
, threadref
*resultlist
,
2494 struct remote_state
*rs
= get_remote_state ();
2496 int count
, resultcount
, done
;
2499 /* Assume the 'q' and 'M chars have been stripped. */
2500 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2501 /* done parse past here */
2502 pkt
= unpack_byte (pkt
, &count
); /* count field */
2503 pkt
= unpack_nibble (pkt
, &done
);
2504 /* The first threadid is the argument threadid. */
2505 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2506 while ((count
-- > 0) && (pkt
< limit
))
2508 pkt
= unpack_threadid (pkt
, resultlist
++);
2509 if (resultcount
++ >= result_limit
)
2518 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2519 int *done
, int *result_count
, threadref
*threadlist
)
2521 struct remote_state
*rs
= get_remote_state ();
2524 /* Trancate result limit to be smaller than the packet size. */
2525 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
2526 >= get_remote_packet_size ())
2527 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2529 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2531 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2533 if (*rs
->buf
== '\0')
2537 parse_threadlist_response (rs
->buf
+ 2, result_limit
,
2538 &rs
->echo_nextthread
, threadlist
, done
);
2540 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
2542 /* FIXME: This is a good reason to drop the packet. */
2543 /* Possably, there is a duplicate response. */
2545 retransmit immediatly - race conditions
2546 retransmit after timeout - yes
2548 wait for packet, then exit
2550 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2551 return 0; /* I choose simply exiting. */
2553 if (*result_count
<= 0)
2557 warning (_("RMT ERROR : failed to get remote thread list."));
2560 return result
; /* break; */
2562 if (*result_count
> result_limit
)
2565 warning (_("RMT ERROR: threadlist response longer than requested."));
2571 /* This is the interface between remote and threads, remotes upper
2574 /* remote_find_new_threads retrieves the thread list and for each
2575 thread in the list, looks up the thread in GDB's internal list,
2576 adding the thread if it does not already exist. This involves
2577 getting partial thread lists from the remote target so, polling the
2578 quit_flag is required. */
2582 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2585 struct remote_state
*rs
= get_remote_state ();
2586 int done
, i
, result_count
;
2594 if (loopcount
++ > looplimit
)
2597 warning (_("Remote fetch threadlist -infinite loop-."));
2600 if (!remote_get_threadlist (startflag
, &rs
->nextthread
,
2601 MAXTHREADLISTRESULTS
,
2602 &done
, &result_count
, rs
->resultthreadlist
))
2607 /* Clear for later iterations. */
2609 /* Setup to resume next batch of thread references, set nextthread. */
2610 if (result_count
>= 1)
2611 copy_threadref (&rs
->nextthread
,
2612 &rs
->resultthreadlist
[result_count
- 1]);
2614 while (result_count
--)
2615 if (!(result
= (*stepfunction
) (&rs
->resultthreadlist
[i
++], context
)))
2622 remote_newthread_step (threadref
*ref
, void *context
)
2624 int pid
= ptid_get_pid (inferior_ptid
);
2625 ptid_t ptid
= ptid_build (pid
, 0, threadref_to_int (ref
));
2627 if (!in_thread_list (ptid
))
2629 return 1; /* continue iterator */
2632 #define CRAZY_MAX_THREADS 1000
2635 remote_current_thread (ptid_t oldpid
)
2637 struct remote_state
*rs
= get_remote_state ();
2640 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2641 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
2642 return read_ptid (&rs
->buf
[2], NULL
);
2647 /* Find new threads for info threads command.
2648 * Original version, using John Metzler's thread protocol.
2652 remote_find_new_threads (void)
2654 remote_threadlist_iterator (remote_newthread_step
, 0,
2658 #if defined(HAVE_LIBEXPAT)
2660 typedef struct thread_item
2666 DEF_VEC_O(thread_item_t
);
2668 struct threads_parsing_context
2670 VEC (thread_item_t
) *items
;
2674 start_thread (struct gdb_xml_parser
*parser
,
2675 const struct gdb_xml_element
*element
,
2676 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
2678 struct threads_parsing_context
*data
= user_data
;
2680 struct thread_item item
;
2682 struct gdb_xml_value
*attr
;
2684 id
= xml_find_attribute (attributes
, "id")->value
;
2685 item
.ptid
= read_ptid (id
, NULL
);
2687 attr
= xml_find_attribute (attributes
, "core");
2689 item
.core
= *(ULONGEST
*) attr
->value
;
2695 VEC_safe_push (thread_item_t
, data
->items
, &item
);
2699 end_thread (struct gdb_xml_parser
*parser
,
2700 const struct gdb_xml_element
*element
,
2701 void *user_data
, const char *body_text
)
2703 struct threads_parsing_context
*data
= user_data
;
2705 if (body_text
&& *body_text
)
2706 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
2709 const struct gdb_xml_attribute thread_attributes
[] = {
2710 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
2711 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2712 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2715 const struct gdb_xml_element thread_children
[] = {
2716 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2719 const struct gdb_xml_element threads_children
[] = {
2720 { "thread", thread_attributes
, thread_children
,
2721 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
2722 start_thread
, end_thread
},
2723 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2726 const struct gdb_xml_element threads_elements
[] = {
2727 { "threads", NULL
, threads_children
,
2728 GDB_XML_EF_NONE
, NULL
, NULL
},
2729 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2732 /* Discard the contents of the constructed thread info context. */
2735 clear_threads_parsing_context (void *p
)
2737 struct threads_parsing_context
*context
= p
;
2739 struct thread_item
*item
;
2741 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
2742 xfree (item
->extra
);
2744 VEC_free (thread_item_t
, context
->items
);
2750 * Find all threads for info threads command.
2751 * Uses new thread protocol contributed by Cisco.
2752 * Falls back and attempts to use the older method (above)
2753 * if the target doesn't respond to the new method.
2757 remote_threads_info (struct target_ops
*ops
)
2759 struct remote_state
*rs
= get_remote_state ();
2763 if (rs
->remote_desc
== 0) /* paranoia */
2764 error (_("Command can only be used when connected to the remote target."));
2766 #if defined(HAVE_LIBEXPAT)
2767 if (remote_protocol_packets
[PACKET_qXfer_threads
].support
== PACKET_ENABLE
)
2769 char *xml
= target_read_stralloc (¤t_target
,
2770 TARGET_OBJECT_THREADS
, NULL
);
2772 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
2776 struct threads_parsing_context context
;
2778 context
.items
= NULL
;
2779 make_cleanup (clear_threads_parsing_context
, &context
);
2781 if (gdb_xml_parse_quick (_("threads"), "threads.dtd",
2782 threads_elements
, xml
, &context
) == 0)
2785 struct thread_item
*item
;
2788 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
2791 if (!ptid_equal (item
->ptid
, null_ptid
))
2793 struct private_thread_info
*info
;
2794 /* In non-stop mode, we assume new found threads
2795 are running until proven otherwise with a
2796 stop reply. In all-stop, we can only get
2797 here if all threads are stopped. */
2798 int running
= non_stop
? 1 : 0;
2800 remote_notice_new_inferior (item
->ptid
, running
);
2802 info
= demand_private_info (item
->ptid
);
2803 info
->core
= item
->core
;
2804 info
->extra
= item
->extra
;
2811 do_cleanups (back_to
);
2816 if (rs
->use_threadinfo_query
)
2818 putpkt ("qfThreadInfo");
2819 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2821 if (bufp
[0] != '\0') /* q packet recognized */
2823 struct cleanup
*old_chain
;
2826 /* remote_notice_new_inferior (in the loop below) may make
2827 new RSP calls, which clobber rs->buf. Work with a
2829 bufp
= saved_reply
= xstrdup (rs
->buf
);
2830 old_chain
= make_cleanup (free_current_contents
, &saved_reply
);
2832 while (*bufp
++ == 'm') /* reply contains one or more TID */
2836 new_thread
= read_ptid (bufp
, &bufp
);
2837 if (!ptid_equal (new_thread
, null_ptid
))
2839 /* In non-stop mode, we assume new found threads
2840 are running until proven otherwise with a
2841 stop reply. In all-stop, we can only get
2842 here if all threads are stopped. */
2843 int running
= non_stop
? 1 : 0;
2845 remote_notice_new_inferior (new_thread
, running
);
2848 while (*bufp
++ == ','); /* comma-separated list */
2849 free_current_contents (&saved_reply
);
2850 putpkt ("qsThreadInfo");
2851 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2852 bufp
= saved_reply
= xstrdup (rs
->buf
);
2854 do_cleanups (old_chain
);
2859 /* Only qfThreadInfo is supported in non-stop mode. */
2863 /* Else fall back to old method based on jmetzler protocol. */
2864 rs
->use_threadinfo_query
= 0;
2865 remote_find_new_threads ();
2870 * Collect a descriptive string about the given thread.
2871 * The target may say anything it wants to about the thread
2872 * (typically info about its blocked / runnable state, name, etc.).
2873 * This string will appear in the info threads display.
2875 * Optional: targets are not required to implement this function.
2879 remote_threads_extra_info (struct thread_info
*tp
)
2881 struct remote_state
*rs
= get_remote_state ();
2885 struct gdb_ext_thread_info threadinfo
;
2886 static char display_buf
[100]; /* arbitrary... */
2887 int n
= 0; /* position in display_buf */
2889 if (rs
->remote_desc
== 0) /* paranoia */
2890 internal_error (__FILE__
, __LINE__
,
2891 _("remote_threads_extra_info"));
2893 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
2894 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_tid (tp
->ptid
) == 0))
2895 /* This is the main thread which was added by GDB. The remote
2896 server doesn't know about it. */
2899 if (remote_protocol_packets
[PACKET_qXfer_threads
].support
== PACKET_ENABLE
)
2901 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
2903 if (info
&& info
->private)
2904 return info
->private->extra
;
2909 if (rs
->use_threadextra_query
)
2912 char *endb
= rs
->buf
+ get_remote_packet_size ();
2914 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
2916 write_ptid (b
, endb
, tp
->ptid
);
2919 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2920 if (rs
->buf
[0] != 0)
2922 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
2923 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
2924 display_buf
[result
] = '\0';
2929 /* If the above query fails, fall back to the old method. */
2930 rs
->use_threadextra_query
= 0;
2931 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
2932 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
2933 int_to_threadref (&id
, ptid_get_tid (tp
->ptid
));
2934 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
2935 if (threadinfo
.active
)
2937 if (*threadinfo
.shortname
)
2938 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
2939 " Name: %s,", threadinfo
.shortname
);
2940 if (*threadinfo
.display
)
2941 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
2942 " State: %s,", threadinfo
.display
);
2943 if (*threadinfo
.more_display
)
2944 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
2945 " Priority: %s", threadinfo
.more_display
);
2949 /* For purely cosmetic reasons, clear up trailing commas. */
2950 if (',' == display_buf
[n
-1])
2951 display_buf
[n
-1] = ' ';
2960 remote_static_tracepoint_marker_at (CORE_ADDR addr
,
2961 struct static_tracepoint_marker
*marker
)
2963 struct remote_state
*rs
= get_remote_state ();
2966 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
2968 p
+= hexnumstr (p
, addr
);
2970 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2974 error (_("Remote failure reply: %s"), p
);
2978 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
2985 static VEC(static_tracepoint_marker_p
) *
2986 remote_static_tracepoint_markers_by_strid (const char *strid
)
2988 struct remote_state
*rs
= get_remote_state ();
2989 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
2990 struct static_tracepoint_marker
*marker
= NULL
;
2991 struct cleanup
*old_chain
;
2994 /* Ask for a first packet of static tracepoint marker
2997 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3000 error (_("Remote failure reply: %s"), p
);
3002 old_chain
= make_cleanup (free_current_marker
, &marker
);
3007 marker
= XCNEW (struct static_tracepoint_marker
);
3011 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3013 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
3015 VEC_safe_push (static_tracepoint_marker_p
,
3021 release_static_tracepoint_marker (marker
);
3022 memset (marker
, 0, sizeof (*marker
));
3025 while (*p
++ == ','); /* comma-separated list */
3026 /* Ask for another packet of static tracepoint definition. */
3028 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3032 do_cleanups (old_chain
);
3037 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3040 remote_get_ada_task_ptid (long lwp
, long thread
)
3042 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
3046 /* Restart the remote side; this is an extended protocol operation. */
3049 extended_remote_restart (void)
3051 struct remote_state
*rs
= get_remote_state ();
3053 /* Send the restart command; for reasons I don't understand the
3054 remote side really expects a number after the "R". */
3055 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
3058 remote_fileio_reset ();
3061 /* Clean up connection to a remote debugger. */
3066 struct remote_state
*rs
= get_remote_state ();
3068 if (rs
->remote_desc
== NULL
)
3069 return; /* already closed */
3071 /* Make sure we leave stdin registered in the event loop, and we
3072 don't leave the async SIGINT signal handler installed. */
3073 remote_terminal_ours ();
3075 serial_close (rs
->remote_desc
);
3076 rs
->remote_desc
= NULL
;
3078 /* We don't have a connection to the remote stub anymore. Get rid
3079 of all the inferiors and their threads we were controlling.
3080 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3081 will be unable to find the thread corresponding to (pid, 0, 0). */
3082 inferior_ptid
= null_ptid
;
3083 discard_all_inferiors ();
3085 /* We are closing the remote target, so we should discard
3086 everything of this target. */
3087 discard_pending_stop_replies_in_queue (rs
);
3089 if (remote_async_inferior_event_token
)
3090 delete_async_event_handler (&remote_async_inferior_event_token
);
3092 remote_notif_state_xfree (rs
->notif_state
);
3094 trace_reset_local_state ();
3097 /* Query the remote side for the text, data and bss offsets. */
3102 struct remote_state
*rs
= get_remote_state ();
3105 int lose
, num_segments
= 0, do_sections
, do_segments
;
3106 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
3107 struct section_offsets
*offs
;
3108 struct symfile_segment_data
*data
;
3110 if (symfile_objfile
== NULL
)
3113 putpkt ("qOffsets");
3114 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3117 if (buf
[0] == '\000')
3118 return; /* Return silently. Stub doesn't support
3122 warning (_("Remote failure reply: %s"), buf
);
3126 /* Pick up each field in turn. This used to be done with scanf, but
3127 scanf will make trouble if CORE_ADDR size doesn't match
3128 conversion directives correctly. The following code will work
3129 with any size of CORE_ADDR. */
3130 text_addr
= data_addr
= bss_addr
= 0;
3134 if (strncmp (ptr
, "Text=", 5) == 0)
3137 /* Don't use strtol, could lose on big values. */
3138 while (*ptr
&& *ptr
!= ';')
3139 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3141 if (strncmp (ptr
, ";Data=", 6) == 0)
3144 while (*ptr
&& *ptr
!= ';')
3145 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3150 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
3153 while (*ptr
&& *ptr
!= ';')
3154 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
3156 if (bss_addr
!= data_addr
)
3157 warning (_("Target reported unsupported offsets: %s"), buf
);
3162 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
3165 /* Don't use strtol, could lose on big values. */
3166 while (*ptr
&& *ptr
!= ';')
3167 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3170 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
3173 while (*ptr
&& *ptr
!= ';')
3174 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3182 error (_("Malformed response to offset query, %s"), buf
);
3183 else if (*ptr
!= '\0')
3184 warning (_("Target reported unsupported offsets: %s"), buf
);
3186 offs
= ((struct section_offsets
*)
3187 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
3188 memcpy (offs
, symfile_objfile
->section_offsets
,
3189 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
3191 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
3192 do_segments
= (data
!= NULL
);
3193 do_sections
= num_segments
== 0;
3195 if (num_segments
> 0)
3197 segments
[0] = text_addr
;
3198 segments
[1] = data_addr
;
3200 /* If we have two segments, we can still try to relocate everything
3201 by assuming that the .text and .data offsets apply to the whole
3202 text and data segments. Convert the offsets given in the packet
3203 to base addresses for symfile_map_offsets_to_segments. */
3204 else if (data
&& data
->num_segments
== 2)
3206 segments
[0] = data
->segment_bases
[0] + text_addr
;
3207 segments
[1] = data
->segment_bases
[1] + data_addr
;
3210 /* If the object file has only one segment, assume that it is text
3211 rather than data; main programs with no writable data are rare,
3212 but programs with no code are useless. Of course the code might
3213 have ended up in the data segment... to detect that we would need
3214 the permissions here. */
3215 else if (data
&& data
->num_segments
== 1)
3217 segments
[0] = data
->segment_bases
[0] + text_addr
;
3220 /* There's no way to relocate by segment. */
3226 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
3227 offs
, num_segments
, segments
);
3229 if (ret
== 0 && !do_sections
)
3230 error (_("Can not handle qOffsets TextSeg "
3231 "response with this symbol file"));
3238 free_symfile_segment_data (data
);
3242 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
3244 /* This is a temporary kludge to force data and bss to use the
3245 same offsets because that's what nlmconv does now. The real
3246 solution requires changes to the stub and remote.c that I
3247 don't have time to do right now. */
3249 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
3250 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
3253 objfile_relocate (symfile_objfile
, offs
);
3256 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in
3257 threads we know are stopped already. This is used during the
3258 initial remote connection in non-stop mode --- threads that are
3259 reported as already being stopped are left stopped. */
3262 set_stop_requested_callback (struct thread_info
*thread
, void *data
)
3264 /* If we have a stop reply for this thread, it must be stopped. */
3265 if (peek_stop_reply (thread
->ptid
))
3266 set_stop_requested (thread
->ptid
, 1);
3271 /* Send interrupt_sequence to remote target. */
3273 send_interrupt_sequence (void)
3275 struct remote_state
*rs
= get_remote_state ();
3277 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
3278 remote_serial_write ("\x03", 1);
3279 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
3280 serial_send_break (rs
->remote_desc
);
3281 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
3283 serial_send_break (rs
->remote_desc
);
3284 remote_serial_write ("g", 1);
3287 internal_error (__FILE__
, __LINE__
,
3288 _("Invalid value for interrupt_sequence_mode: %s."),
3289 interrupt_sequence_mode
);
3293 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3294 and extract the PTID. Returns NULL_PTID if not found. */
3297 stop_reply_extract_thread (char *stop_reply
)
3299 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
3303 /* Txx r:val ; r:val (...) */
3306 /* Look for "register" named "thread". */
3311 p1
= strchr (p
, ':');
3315 if (strncmp (p
, "thread", p1
- p
) == 0)
3316 return read_ptid (++p1
, &p
);
3318 p1
= strchr (p
, ';');
3330 /* Determine the remote side's current thread. If we have a stop
3331 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3332 "thread" register we can extract the current thread from. If not,
3333 ask the remote which is the current thread with qC. The former
3334 method avoids a roundtrip. */
3337 get_current_thread (char *wait_status
)
3341 /* Note we don't use remote_parse_stop_reply as that makes use of
3342 the target architecture, which we haven't yet fully determined at
3344 if (wait_status
!= NULL
)
3345 ptid
= stop_reply_extract_thread (wait_status
);
3346 if (ptid_equal (ptid
, null_ptid
))
3347 ptid
= remote_current_thread (inferior_ptid
);
3352 /* Query the remote target for which is the current thread/process,
3353 add it to our tables, and update INFERIOR_PTID. The caller is
3354 responsible for setting the state such that the remote end is ready
3355 to return the current thread.
3357 This function is called after handling the '?' or 'vRun' packets,
3358 whose response is a stop reply from which we can also try
3359 extracting the thread. If the target doesn't support the explicit
3360 qC query, we infer the current thread from that stop reply, passed
3361 in in WAIT_STATUS, which may be NULL. */
3364 add_current_inferior_and_thread (char *wait_status
)
3366 struct remote_state
*rs
= get_remote_state ();
3368 ptid_t ptid
= null_ptid
;
3370 inferior_ptid
= null_ptid
;
3372 /* Now, if we have thread information, update inferior_ptid. */
3373 ptid
= get_current_thread (wait_status
);
3375 if (!ptid_equal (ptid
, null_ptid
))
3377 if (!remote_multi_process_p (rs
))
3380 inferior_ptid
= ptid
;
3384 /* Without this, some commands which require an active target
3385 (such as kill) won't work. This variable serves (at least)
3386 double duty as both the pid of the target process (if it has
3387 such), and as a flag indicating that a target is active. */
3388 inferior_ptid
= magic_null_ptid
;
3392 remote_add_inferior (fake_pid_p
, ptid_get_pid (inferior_ptid
), -1);
3394 /* Add the main thread. */
3395 add_thread_silent (inferior_ptid
);
3399 remote_start_remote (int from_tty
, struct target_ops
*target
, int extended_p
)
3401 struct remote_state
*rs
= get_remote_state ();
3402 struct packet_config
*noack_config
;
3403 char *wait_status
= NULL
;
3405 immediate_quit
++; /* Allow user to interrupt it. */
3408 if (interrupt_on_connect
)
3409 send_interrupt_sequence ();
3411 /* Ack any packet which the remote side has already sent. */
3412 serial_write (rs
->remote_desc
, "+", 1);
3414 /* Signal other parts that we're going through the initial setup,
3415 and so things may not be stable yet. */
3416 rs
->starting_up
= 1;
3418 /* The first packet we send to the target is the optional "supported
3419 packets" request. If the target can answer this, it will tell us
3420 which later probes to skip. */
3421 remote_query_supported ();
3423 /* If the stub wants to get a QAllow, compose one and send it. */
3424 if (remote_protocol_packets
[PACKET_QAllow
].support
!= PACKET_DISABLE
)
3425 remote_set_permissions ();
3427 /* Next, we possibly activate noack mode.
3429 If the QStartNoAckMode packet configuration is set to AUTO,
3430 enable noack mode if the stub reported a wish for it with
3433 If set to TRUE, then enable noack mode even if the stub didn't
3434 report it in qSupported. If the stub doesn't reply OK, the
3435 session ends with an error.
3437 If FALSE, then don't activate noack mode, regardless of what the
3438 stub claimed should be the default with qSupported. */
3440 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
3442 if (noack_config
->detect
== AUTO_BOOLEAN_TRUE
3443 || (noack_config
->detect
== AUTO_BOOLEAN_AUTO
3444 && noack_config
->support
== PACKET_ENABLE
))
3446 putpkt ("QStartNoAckMode");
3447 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3448 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
3454 /* Tell the remote that we are using the extended protocol. */
3456 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3459 /* Let the target know which signals it is allowed to pass down to
3461 update_signals_program_target ();
3463 /* Next, if the target can specify a description, read it. We do
3464 this before anything involving memory or registers. */
3465 target_find_description ();
3467 /* Next, now that we know something about the target, update the
3468 address spaces in the program spaces. */
3469 update_address_spaces ();
3471 /* On OSs where the list of libraries is global to all
3472 processes, we fetch them early. */
3473 if (gdbarch_has_global_solist (target_gdbarch ()))
3474 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
3478 if (!rs
->non_stop_aware
)
3479 error (_("Non-stop mode requested, but remote "
3480 "does not support non-stop"));
3482 putpkt ("QNonStop:1");
3483 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3485 if (strcmp (rs
->buf
, "OK") != 0)
3486 error (_("Remote refused setting non-stop mode with: %s"), rs
->buf
);
3488 /* Find about threads and processes the stub is already
3489 controlling. We default to adding them in the running state.
3490 The '?' query below will then tell us about which threads are
3492 remote_threads_info (target
);
3494 else if (rs
->non_stop_aware
)
3496 /* Don't assume that the stub can operate in all-stop mode.
3497 Request it explicitly. */
3498 putpkt ("QNonStop:0");
3499 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3501 if (strcmp (rs
->buf
, "OK") != 0)
3502 error (_("Remote refused setting all-stop mode with: %s"), rs
->buf
);
3505 /* Upload TSVs regardless of whether the target is running or not. The
3506 remote stub, such as GDBserver, may have some predefined or builtin
3507 TSVs, even if the target is not running. */
3508 if (remote_get_trace_status (current_trace_status ()) != -1)
3510 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3512 remote_upload_trace_state_variables (&uploaded_tsvs
);
3513 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3516 /* Check whether the target is running now. */
3518 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3524 struct inferior
*inf
;
3526 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
3529 error (_("The target is not running (try extended-remote?)"));
3531 /* We're connected, but not running. Drop out before we
3532 call start_remote. */
3533 rs
->starting_up
= 0;
3538 /* Save the reply for later. */
3539 wait_status
= alloca (strlen (rs
->buf
) + 1);
3540 strcpy (wait_status
, rs
->buf
);
3543 /* Fetch thread list. */
3544 target_find_new_threads ();
3546 /* Let the stub know that we want it to return the thread. */
3547 set_continue_thread (minus_one_ptid
);
3549 if (thread_count () == 0)
3551 /* Target has no concept of threads at all. GDB treats
3552 non-threaded target as single-threaded; add a main
3554 add_current_inferior_and_thread (wait_status
);
3558 /* We have thread information; select the thread the target
3559 says should be current. If we're reconnecting to a
3560 multi-threaded program, this will ideally be the thread
3561 that last reported an event before GDB disconnected. */
3562 inferior_ptid
= get_current_thread (wait_status
);
3563 if (ptid_equal (inferior_ptid
, null_ptid
))
3565 /* Odd... The target was able to list threads, but not
3566 tell us which thread was current (no "thread"
3567 register in T stop reply?). Just pick the first
3568 thread in the thread list then. */
3569 inferior_ptid
= thread_list
->ptid
;
3573 /* init_wait_for_inferior should be called before get_offsets in order
3574 to manage `inserted' flag in bp loc in a correct state.
3575 breakpoint_init_inferior, called from init_wait_for_inferior, set
3576 `inserted' flag to 0, while before breakpoint_re_set, called from
3577 start_remote, set `inserted' flag to 1. In the initialization of
3578 inferior, breakpoint_init_inferior should be called first, and then
3579 breakpoint_re_set can be called. If this order is broken, state of
3580 `inserted' flag is wrong, and cause some problems on breakpoint
3582 init_wait_for_inferior ();
3584 get_offsets (); /* Get text, data & bss offsets. */
3586 /* If we could not find a description using qXfer, and we know
3587 how to do it some other way, try again. This is not
3588 supported for non-stop; it could be, but it is tricky if
3589 there are no stopped threads when we connect. */
3590 if (remote_read_description_p (target
)
3591 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
3593 target_clear_description ();
3594 target_find_description ();
3597 /* Use the previously fetched status. */
3598 gdb_assert (wait_status
!= NULL
);
3599 strcpy (rs
->buf
, wait_status
);
3600 rs
->cached_wait_status
= 1;
3603 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
3607 /* Clear WFI global state. Do this before finding about new
3608 threads and inferiors, and setting the current inferior.
3609 Otherwise we would clear the proceed status of the current
3610 inferior when we want its stop_soon state to be preserved
3611 (see notice_new_inferior). */
3612 init_wait_for_inferior ();
3614 /* In non-stop, we will either get an "OK", meaning that there
3615 are no stopped threads at this time; or, a regular stop
3616 reply. In the latter case, there may be more than one thread
3617 stopped --- we pull them all out using the vStopped
3619 if (strcmp (rs
->buf
, "OK") != 0)
3621 struct notif_client
*notif
= ¬if_client_stop
;
3623 /* remote_notif_get_pending_replies acks this one, and gets
3625 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
3626 = remote_notif_parse (notif
, rs
->buf
);
3627 remote_notif_get_pending_events (notif
);
3629 /* Make sure that threads that were stopped remain
3631 iterate_over_threads (set_stop_requested_callback
, NULL
);
3634 if (target_can_async_p ())
3635 target_async (inferior_event_handler
, 0);
3637 if (thread_count () == 0)
3640 error (_("The target is not running (try extended-remote?)"));
3642 /* We're connected, but not running. Drop out before we
3643 call start_remote. */
3644 rs
->starting_up
= 0;
3648 /* Let the stub know that we want it to return the thread. */
3650 /* Force the stub to choose a thread. */
3651 set_general_thread (null_ptid
);
3654 inferior_ptid
= remote_current_thread (minus_one_ptid
);
3655 if (ptid_equal (inferior_ptid
, minus_one_ptid
))
3656 error (_("remote didn't report the current thread in non-stop mode"));
3658 get_offsets (); /* Get text, data & bss offsets. */
3660 /* In non-stop mode, any cached wait status will be stored in
3661 the stop reply queue. */
3662 gdb_assert (wait_status
== NULL
);
3664 /* Report all signals during attach/startup. */
3665 remote_pass_signals (0, NULL
);
3668 /* If we connected to a live target, do some additional setup. */
3669 if (target_has_execution
)
3671 if (exec_bfd
) /* No use without an exec file. */
3672 remote_check_symbols ();
3675 /* Possibly the target has been engaged in a trace run started
3676 previously; find out where things are at. */
3677 if (remote_get_trace_status (current_trace_status ()) != -1)
3679 struct uploaded_tp
*uploaded_tps
= NULL
;
3681 if (current_trace_status ()->running
)
3682 printf_filtered (_("Trace is already running on the target.\n"));
3684 remote_upload_tracepoints (&uploaded_tps
);
3686 merge_uploaded_tracepoints (&uploaded_tps
);
3689 /* The thread and inferior lists are now synchronized with the
3690 target, our symbols have been relocated, and we're merged the
3691 target's tracepoints with ours. We're done with basic start
3693 rs
->starting_up
= 0;
3695 /* If breakpoints are global, insert them now. */
3696 if (gdbarch_has_global_breakpoints (target_gdbarch ())
3697 && breakpoints_always_inserted_mode ())
3698 insert_breakpoints ();
3701 /* Open a connection to a remote debugger.
3702 NAME is the filename used for communication. */
3705 remote_open (char *name
, int from_tty
)
3707 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
3710 /* Open a connection to a remote debugger using the extended
3711 remote gdb protocol. NAME is the filename used for communication. */
3714 extended_remote_open (char *name
, int from_tty
)
3716 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
3719 /* Generic code for opening a connection to a remote target. */
3722 init_all_packet_configs (void)
3726 for (i
= 0; i
< PACKET_MAX
; i
++)
3727 update_packet_config (&remote_protocol_packets
[i
]);
3730 /* Symbol look-up. */
3733 remote_check_symbols (void)
3735 struct remote_state
*rs
= get_remote_state ();
3736 char *msg
, *reply
, *tmp
;
3737 struct minimal_symbol
*sym
;
3740 /* The remote side has no concept of inferiors that aren't running
3741 yet, it only knows about running processes. If we're connected
3742 but our current inferior is not running, we should not invite the
3743 remote target to request symbol lookups related to its
3744 (unrelated) current process. */
3745 if (!target_has_execution
)
3748 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
3751 /* Make sure the remote is pointing at the right process. Note
3752 there's no way to select "no process". */
3753 set_general_process ();
3755 /* Allocate a message buffer. We can't reuse the input buffer in RS,
3756 because we need both at the same time. */
3757 msg
= alloca (get_remote_packet_size ());
3759 /* Invite target to request symbol lookups. */
3761 putpkt ("qSymbol::");
3762 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3763 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
3766 while (strncmp (reply
, "qSymbol:", 8) == 0)
3769 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
3771 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
3773 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
3776 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
3777 CORE_ADDR sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
3779 /* If this is a function address, return the start of code
3780 instead of any data function descriptor. */
3781 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
3785 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
3786 phex_nz (sym_addr
, addr_size
), &reply
[8]);
3790 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3795 static struct serial
*
3796 remote_serial_open (char *name
)
3798 static int udp_warning
= 0;
3800 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
3801 of in ser-tcp.c, because it is the remote protocol assuming that the
3802 serial connection is reliable and not the serial connection promising
3804 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
3806 warning (_("The remote protocol may be unreliable over UDP.\n"
3807 "Some events may be lost, rendering further debugging "
3812 return serial_open (name
);
3815 /* Inform the target of our permission settings. The permission flags
3816 work without this, but if the target knows the settings, it can do
3817 a couple things. First, it can add its own check, to catch cases
3818 that somehow manage to get by the permissions checks in target
3819 methods. Second, if the target is wired to disallow particular
3820 settings (for instance, a system in the field that is not set up to
3821 be able to stop at a breakpoint), it can object to any unavailable
3825 remote_set_permissions (void)
3827 struct remote_state
*rs
= get_remote_state ();
3829 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAllow:"
3830 "WriteReg:%x;WriteMem:%x;"
3831 "InsertBreak:%x;InsertTrace:%x;"
3832 "InsertFastTrace:%x;Stop:%x",
3833 may_write_registers
, may_write_memory
,
3834 may_insert_breakpoints
, may_insert_tracepoints
,
3835 may_insert_fast_tracepoints
, may_stop
);
3837 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3839 /* If the target didn't like the packet, warn the user. Do not try
3840 to undo the user's settings, that would just be maddening. */
3841 if (strcmp (rs
->buf
, "OK") != 0)
3842 warning (_("Remote refused setting permissions with: %s"), rs
->buf
);
3845 /* This type describes each known response to the qSupported
3847 struct protocol_feature
3849 /* The name of this protocol feature. */
3852 /* The default for this protocol feature. */
3853 enum packet_support default_support
;
3855 /* The function to call when this feature is reported, or after
3856 qSupported processing if the feature is not supported.
3857 The first argument points to this structure. The second
3858 argument indicates whether the packet requested support be
3859 enabled, disabled, or probed (or the default, if this function
3860 is being called at the end of processing and this feature was
3861 not reported). The third argument may be NULL; if not NULL, it
3862 is a NUL-terminated string taken from the packet following
3863 this feature's name and an equals sign. */
3864 void (*func
) (const struct protocol_feature
*, enum packet_support
,
3867 /* The corresponding packet for this feature. Only used if
3868 FUNC is remote_supported_packet. */
3873 remote_supported_packet (const struct protocol_feature
*feature
,
3874 enum packet_support support
,
3875 const char *argument
)
3879 warning (_("Remote qSupported response supplied an unexpected value for"
3880 " \"%s\"."), feature
->name
);
3884 if (remote_protocol_packets
[feature
->packet
].support
3885 == PACKET_SUPPORT_UNKNOWN
)
3886 remote_protocol_packets
[feature
->packet
].support
= support
;
3890 remote_packet_size (const struct protocol_feature
*feature
,
3891 enum packet_support support
, const char *value
)
3893 struct remote_state
*rs
= get_remote_state ();
3898 if (support
!= PACKET_ENABLE
)
3901 if (value
== NULL
|| *value
== '\0')
3903 warning (_("Remote target reported \"%s\" without a size."),
3909 packet_size
= strtol (value
, &value_end
, 16);
3910 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
3912 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
3913 feature
->name
, value
);
3917 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
3919 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
3920 packet_size
, MAX_REMOTE_PACKET_SIZE
);
3921 packet_size
= MAX_REMOTE_PACKET_SIZE
;
3924 /* Record the new maximum packet size. */
3925 rs
->explicit_packet_size
= packet_size
;
3929 remote_multi_process_feature (const struct protocol_feature
*feature
,
3930 enum packet_support support
, const char *value
)
3932 struct remote_state
*rs
= get_remote_state ();
3934 rs
->multi_process_aware
= (support
== PACKET_ENABLE
);
3938 remote_non_stop_feature (const struct protocol_feature
*feature
,
3939 enum packet_support support
, const char *value
)
3941 struct remote_state
*rs
= get_remote_state ();
3943 rs
->non_stop_aware
= (support
== PACKET_ENABLE
);
3947 remote_cond_tracepoint_feature (const struct protocol_feature
*feature
,
3948 enum packet_support support
,
3951 struct remote_state
*rs
= get_remote_state ();
3953 rs
->cond_tracepoints
= (support
== PACKET_ENABLE
);
3957 remote_cond_breakpoint_feature (const struct protocol_feature
*feature
,
3958 enum packet_support support
,
3961 struct remote_state
*rs
= get_remote_state ();
3963 rs
->cond_breakpoints
= (support
== PACKET_ENABLE
);
3967 remote_breakpoint_commands_feature (const struct protocol_feature
*feature
,
3968 enum packet_support support
,
3971 struct remote_state
*rs
= get_remote_state ();
3973 rs
->breakpoint_commands
= (support
== PACKET_ENABLE
);
3977 remote_fast_tracepoint_feature (const struct protocol_feature
*feature
,
3978 enum packet_support support
,
3981 struct remote_state
*rs
= get_remote_state ();
3983 rs
->fast_tracepoints
= (support
== PACKET_ENABLE
);
3987 remote_static_tracepoint_feature (const struct protocol_feature
*feature
,
3988 enum packet_support support
,
3991 struct remote_state
*rs
= get_remote_state ();
3993 rs
->static_tracepoints
= (support
== PACKET_ENABLE
);
3997 remote_install_in_trace_feature (const struct protocol_feature
*feature
,
3998 enum packet_support support
,
4001 struct remote_state
*rs
= get_remote_state ();
4003 rs
->install_in_trace
= (support
== PACKET_ENABLE
);
4007 remote_disconnected_tracing_feature (const struct protocol_feature
*feature
,
4008 enum packet_support support
,
4011 struct remote_state
*rs
= get_remote_state ();
4013 rs
->disconnected_tracing
= (support
== PACKET_ENABLE
);
4017 remote_enable_disable_tracepoint_feature (const struct protocol_feature
*feature
,
4018 enum packet_support support
,
4021 struct remote_state
*rs
= get_remote_state ();
4023 rs
->enable_disable_tracepoints
= (support
== PACKET_ENABLE
);
4027 remote_string_tracing_feature (const struct protocol_feature
*feature
,
4028 enum packet_support support
,
4031 struct remote_state
*rs
= get_remote_state ();
4033 rs
->string_tracing
= (support
== PACKET_ENABLE
);
4037 remote_augmented_libraries_svr4_read_feature
4038 (const struct protocol_feature
*feature
,
4039 enum packet_support support
, const char *value
)
4041 struct remote_state
*rs
= get_remote_state ();
4043 rs
->augmented_libraries_svr4_read
= (support
== PACKET_ENABLE
);
4046 static const struct protocol_feature remote_protocol_features
[] = {
4047 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
4048 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
4049 PACKET_qXfer_auxv
},
4050 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
4051 PACKET_qXfer_features
},
4052 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
4053 PACKET_qXfer_libraries
},
4054 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
4055 PACKET_qXfer_libraries_svr4
},
4056 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
4057 remote_augmented_libraries_svr4_read_feature
, -1 },
4058 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
4059 PACKET_qXfer_memory_map
},
4060 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
4061 PACKET_qXfer_spu_read
},
4062 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
4063 PACKET_qXfer_spu_write
},
4064 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
4065 PACKET_qXfer_osdata
},
4066 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
4067 PACKET_qXfer_threads
},
4068 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
4069 PACKET_qXfer_traceframe_info
},
4070 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
4071 PACKET_QPassSignals
},
4072 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
4073 PACKET_QProgramSignals
},
4074 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
4075 PACKET_QStartNoAckMode
},
4076 { "multiprocess", PACKET_DISABLE
, remote_multi_process_feature
, -1 },
4077 { "QNonStop", PACKET_DISABLE
, remote_non_stop_feature
, -1 },
4078 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
4079 PACKET_qXfer_siginfo_read
},
4080 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
4081 PACKET_qXfer_siginfo_write
},
4082 { "ConditionalTracepoints", PACKET_DISABLE
, remote_cond_tracepoint_feature
,
4083 PACKET_ConditionalTracepoints
},
4084 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_cond_breakpoint_feature
,
4085 PACKET_ConditionalBreakpoints
},
4086 { "BreakpointCommands", PACKET_DISABLE
, remote_breakpoint_commands_feature
,
4087 PACKET_BreakpointCommands
},
4088 { "FastTracepoints", PACKET_DISABLE
, remote_fast_tracepoint_feature
,
4089 PACKET_FastTracepoints
},
4090 { "StaticTracepoints", PACKET_DISABLE
, remote_static_tracepoint_feature
,
4091 PACKET_StaticTracepoints
},
4092 {"InstallInTrace", PACKET_DISABLE
, remote_install_in_trace_feature
,
4093 PACKET_InstallInTrace
},
4094 { "DisconnectedTracing", PACKET_DISABLE
, remote_disconnected_tracing_feature
,
4096 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
4098 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
4100 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
4101 PACKET_TracepointSource
},
4102 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
4104 { "EnableDisableTracepoints", PACKET_DISABLE
,
4105 remote_enable_disable_tracepoint_feature
, -1 },
4106 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
4107 PACKET_qXfer_fdpic
},
4108 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
4110 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
4111 PACKET_QDisableRandomization
},
4112 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
4113 { "QTBuffer:size", PACKET_DISABLE
,
4114 remote_supported_packet
, PACKET_QTBuffer_size
},
4115 { "tracenz", PACKET_DISABLE
,
4116 remote_string_tracing_feature
, -1 },
4117 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
4118 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
4119 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
4120 PACKET_qXfer_btrace
}
4123 static char *remote_support_xml
;
4125 /* Register string appended to "xmlRegisters=" in qSupported query. */
4128 register_remote_support_xml (const char *xml
)
4130 #if defined(HAVE_LIBEXPAT)
4131 if (remote_support_xml
== NULL
)
4132 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
4135 char *copy
= xstrdup (remote_support_xml
+ 13);
4136 char *p
= strtok (copy
, ",");
4140 if (strcmp (p
, xml
) == 0)
4147 while ((p
= strtok (NULL
, ",")) != NULL
);
4150 remote_support_xml
= reconcat (remote_support_xml
,
4151 remote_support_xml
, ",", xml
,
4158 remote_query_supported_append (char *msg
, const char *append
)
4161 return reconcat (msg
, msg
, ";", append
, (char *) NULL
);
4163 return xstrdup (append
);
4167 remote_query_supported (void)
4169 struct remote_state
*rs
= get_remote_state ();
4172 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
4174 /* The packet support flags are handled differently for this packet
4175 than for most others. We treat an error, a disabled packet, and
4176 an empty response identically: any features which must be reported
4177 to be used will be automatically disabled. An empty buffer
4178 accomplishes this, since that is also the representation for a list
4179 containing no features. */
4182 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
4185 struct cleanup
*old_chain
= make_cleanup (free_current_contents
, &q
);
4187 q
= remote_query_supported_append (q
, "multiprocess+");
4189 if (remote_support_xml
)
4190 q
= remote_query_supported_append (q
, remote_support_xml
);
4192 q
= remote_query_supported_append (q
, "qRelocInsn+");
4194 q
= reconcat (q
, "qSupported:", q
, (char *) NULL
);
4197 do_cleanups (old_chain
);
4199 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4201 /* If an error occured, warn, but do not return - just reset the
4202 buffer to empty and go on to disable features. */
4203 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
4206 warning (_("Remote failure reply: %s"), rs
->buf
);
4211 memset (seen
, 0, sizeof (seen
));
4216 enum packet_support is_supported
;
4217 char *p
, *end
, *name_end
, *value
;
4219 /* First separate out this item from the rest of the packet. If
4220 there's another item after this, we overwrite the separator
4221 (terminated strings are much easier to work with). */
4223 end
= strchr (p
, ';');
4226 end
= p
+ strlen (p
);
4236 warning (_("empty item in \"qSupported\" response"));
4241 name_end
= strchr (p
, '=');
4244 /* This is a name=value entry. */
4245 is_supported
= PACKET_ENABLE
;
4246 value
= name_end
+ 1;
4255 is_supported
= PACKET_ENABLE
;
4259 is_supported
= PACKET_DISABLE
;
4263 is_supported
= PACKET_SUPPORT_UNKNOWN
;
4267 warning (_("unrecognized item \"%s\" "
4268 "in \"qSupported\" response"), p
);
4274 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4275 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
4277 const struct protocol_feature
*feature
;
4280 feature
= &remote_protocol_features
[i
];
4281 feature
->func (feature
, is_supported
, value
);
4286 /* If we increased the packet size, make sure to increase the global
4287 buffer size also. We delay this until after parsing the entire
4288 qSupported packet, because this is the same buffer we were
4290 if (rs
->buf_size
< rs
->explicit_packet_size
)
4292 rs
->buf_size
= rs
->explicit_packet_size
;
4293 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
4296 /* Handle the defaults for unmentioned features. */
4297 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4300 const struct protocol_feature
*feature
;
4302 feature
= &remote_protocol_features
[i
];
4303 feature
->func (feature
, feature
->default_support
, NULL
);
4307 /* Remove any of the remote.c targets from target stack. Upper targets depend
4308 on it so remove them first. */
4311 remote_unpush_target (void)
4313 pop_all_targets_above (process_stratum
- 1);
4317 remote_open_1 (char *name
, int from_tty
,
4318 struct target_ops
*target
, int extended_p
)
4320 struct remote_state
*rs
= get_remote_state ();
4323 error (_("To open a remote debug connection, you need to specify what\n"
4324 "serial device is attached to the remote system\n"
4325 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
4327 /* See FIXME above. */
4328 if (!target_async_permitted
)
4329 wait_forever_enabled_p
= 1;
4331 /* If we're connected to a running target, target_preopen will kill it.
4332 Ask this question first, before target_preopen has a chance to kill
4334 if (rs
->remote_desc
!= NULL
&& !have_inferiors ())
4337 && !query (_("Already connected to a remote target. Disconnect? ")))
4338 error (_("Still connected."));
4341 /* Here the possibly existing remote target gets unpushed. */
4342 target_preopen (from_tty
);
4344 /* Make sure we send the passed signals list the next time we resume. */
4345 xfree (rs
->last_pass_packet
);
4346 rs
->last_pass_packet
= NULL
;
4348 /* Make sure we send the program signals list the next time we
4350 xfree (rs
->last_program_signals_packet
);
4351 rs
->last_program_signals_packet
= NULL
;
4353 remote_fileio_reset ();
4354 reopen_exec_file ();
4357 rs
->remote_desc
= remote_serial_open (name
);
4358 if (!rs
->remote_desc
)
4359 perror_with_name (name
);
4361 if (baud_rate
!= -1)
4363 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
4365 /* The requested speed could not be set. Error out to
4366 top level after closing remote_desc. Take care to
4367 set remote_desc to NULL to avoid closing remote_desc
4369 serial_close (rs
->remote_desc
);
4370 rs
->remote_desc
= NULL
;
4371 perror_with_name (name
);
4375 serial_raw (rs
->remote_desc
);
4377 /* If there is something sitting in the buffer we might take it as a
4378 response to a command, which would be bad. */
4379 serial_flush_input (rs
->remote_desc
);
4383 puts_filtered ("Remote debugging using ");
4384 puts_filtered (name
);
4385 puts_filtered ("\n");
4387 push_target (target
); /* Switch to using remote target now. */
4389 /* Register extra event sources in the event loop. */
4390 remote_async_inferior_event_token
4391 = create_async_event_handler (remote_async_inferior_event_handler
,
4393 rs
->notif_state
= remote_notif_state_allocate ();
4395 /* Reset the target state; these things will be queried either by
4396 remote_query_supported or as they are needed. */
4397 init_all_packet_configs ();
4398 rs
->cached_wait_status
= 0;
4399 rs
->explicit_packet_size
= 0;
4401 rs
->multi_process_aware
= 0;
4402 rs
->extended
= extended_p
;
4403 rs
->non_stop_aware
= 0;
4404 rs
->waiting_for_stop_reply
= 0;
4405 rs
->ctrlc_pending_p
= 0;
4407 rs
->general_thread
= not_sent_ptid
;
4408 rs
->continue_thread
= not_sent_ptid
;
4409 rs
->remote_traceframe_number
= -1;
4411 /* Probe for ability to use "ThreadInfo" query, as required. */
4412 rs
->use_threadinfo_query
= 1;
4413 rs
->use_threadextra_query
= 1;
4415 if (target_async_permitted
)
4417 /* With this target we start out by owning the terminal. */
4418 remote_async_terminal_ours_p
= 1;
4420 /* FIXME: cagney/1999-09-23: During the initial connection it is
4421 assumed that the target is already ready and able to respond to
4422 requests. Unfortunately remote_start_remote() eventually calls
4423 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
4424 around this. Eventually a mechanism that allows
4425 wait_for_inferior() to expect/get timeouts will be
4427 wait_forever_enabled_p
= 0;
4430 /* First delete any symbols previously loaded from shared libraries. */
4431 no_shared_libraries (NULL
, 0);
4434 init_thread_list ();
4436 /* Start the remote connection. If error() or QUIT, discard this
4437 target (we'd otherwise be in an inconsistent state) and then
4438 propogate the error on up the exception chain. This ensures that
4439 the caller doesn't stumble along blindly assuming that the
4440 function succeeded. The CLI doesn't have this problem but other
4441 UI's, such as MI do.
4443 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
4444 this function should return an error indication letting the
4445 caller restore the previous state. Unfortunately the command
4446 ``target remote'' is directly wired to this function making that
4447 impossible. On a positive note, the CLI side of this problem has
4448 been fixed - the function set_cmd_context() makes it possible for
4449 all the ``target ....'' commands to share a common callback
4450 function. See cli-dump.c. */
4452 volatile struct gdb_exception ex
;
4454 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4456 remote_start_remote (from_tty
, target
, extended_p
);
4460 /* Pop the partially set up target - unless something else did
4461 already before throwing the exception. */
4462 if (rs
->remote_desc
!= NULL
)
4463 remote_unpush_target ();
4464 if (target_async_permitted
)
4465 wait_forever_enabled_p
= 1;
4466 throw_exception (ex
);
4470 if (target_async_permitted
)
4471 wait_forever_enabled_p
= 1;
4474 /* This takes a program previously attached to and detaches it. After
4475 this is done, GDB can be used to debug some other program. We
4476 better not have left any breakpoints in the target program or it'll
4477 die when it hits one. */
4480 remote_detach_1 (const char *args
, int from_tty
, int extended
)
4482 int pid
= ptid_get_pid (inferior_ptid
);
4483 struct remote_state
*rs
= get_remote_state ();
4486 error (_("Argument given to \"detach\" when remotely debugging."));
4488 if (!target_has_execution
)
4489 error (_("No process to detach from."));
4493 char *exec_file
= get_exec_file (0);
4494 if (exec_file
== NULL
)
4496 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
4497 target_pid_to_str (pid_to_ptid (pid
)));
4498 gdb_flush (gdb_stdout
);
4501 /* Tell the remote target to detach. */
4502 if (remote_multi_process_p (rs
))
4503 xsnprintf (rs
->buf
, get_remote_packet_size (), "D;%x", pid
);
4505 strcpy (rs
->buf
, "D");
4508 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4510 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
4512 else if (rs
->buf
[0] == '\0')
4513 error (_("Remote doesn't know how to detach"));
4515 error (_("Can't detach process."));
4517 if (from_tty
&& !extended
)
4518 puts_filtered (_("Ending remote debugging.\n"));
4520 target_mourn_inferior ();
4524 remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
4526 remote_detach_1 (args
, from_tty
, 0);
4530 extended_remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
4532 remote_detach_1 (args
, from_tty
, 1);
4535 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
4538 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
4541 error (_("Argument given to \"disconnect\" when remotely debugging."));
4543 /* Make sure we unpush even the extended remote targets; mourn
4544 won't do it. So call remote_mourn_1 directly instead of
4545 target_mourn_inferior. */
4546 remote_mourn_1 (target
);
4549 puts_filtered ("Ending remote debugging.\n");
4552 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
4553 be chatty about it. */
4556 extended_remote_attach_1 (struct target_ops
*target
, char *args
, int from_tty
)
4558 struct remote_state
*rs
= get_remote_state ();
4560 char *wait_status
= NULL
;
4562 pid
= parse_pid_to_attach (args
);
4564 /* Remote PID can be freely equal to getpid, do not check it here the same
4565 way as in other targets. */
4567 if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
4568 error (_("This target does not support attaching to a process"));
4572 char *exec_file
= get_exec_file (0);
4575 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
4576 target_pid_to_str (pid_to_ptid (pid
)));
4578 printf_unfiltered (_("Attaching to %s\n"),
4579 target_pid_to_str (pid_to_ptid (pid
)));
4581 gdb_flush (gdb_stdout
);
4584 xsnprintf (rs
->buf
, get_remote_packet_size (), "vAttach;%x", pid
);
4586 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4588 if (packet_ok (rs
->buf
,
4589 &remote_protocol_packets
[PACKET_vAttach
]) == PACKET_OK
)
4593 /* Save the reply for later. */
4594 wait_status
= alloca (strlen (rs
->buf
) + 1);
4595 strcpy (wait_status
, rs
->buf
);
4597 else if (strcmp (rs
->buf
, "OK") != 0)
4598 error (_("Attaching to %s failed with: %s"),
4599 target_pid_to_str (pid_to_ptid (pid
)),
4602 else if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
4603 error (_("This target does not support attaching to a process"));
4605 error (_("Attaching to %s failed"),
4606 target_pid_to_str (pid_to_ptid (pid
)));
4608 set_current_inferior (remote_add_inferior (0, pid
, 1));
4610 inferior_ptid
= pid_to_ptid (pid
);
4614 struct thread_info
*thread
;
4616 /* Get list of threads. */
4617 remote_threads_info (target
);
4619 thread
= first_thread_of_process (pid
);
4621 inferior_ptid
= thread
->ptid
;
4623 inferior_ptid
= pid_to_ptid (pid
);
4625 /* Invalidate our notion of the remote current thread. */
4626 record_currthread (rs
, minus_one_ptid
);
4630 /* Now, if we have thread information, update inferior_ptid. */
4631 inferior_ptid
= remote_current_thread (inferior_ptid
);
4633 /* Add the main thread to the thread list. */
4634 add_thread_silent (inferior_ptid
);
4637 /* Next, if the target can specify a description, read it. We do
4638 this before anything involving memory or registers. */
4639 target_find_description ();
4643 /* Use the previously fetched status. */
4644 gdb_assert (wait_status
!= NULL
);
4646 if (target_can_async_p ())
4648 struct notif_event
*reply
4649 = remote_notif_parse (¬if_client_stop
, wait_status
);
4651 push_stop_reply ((struct stop_reply
*) reply
);
4653 target_async (inferior_event_handler
, 0);
4657 gdb_assert (wait_status
!= NULL
);
4658 strcpy (rs
->buf
, wait_status
);
4659 rs
->cached_wait_status
= 1;
4663 gdb_assert (wait_status
== NULL
);
4667 extended_remote_attach (struct target_ops
*ops
, char *args
, int from_tty
)
4669 extended_remote_attach_1 (ops
, args
, from_tty
);
4672 /* Convert hex digit A to a number. */
4677 if (a
>= '0' && a
<= '9')
4679 else if (a
>= 'a' && a
<= 'f')
4680 return a
- 'a' + 10;
4681 else if (a
>= 'A' && a
<= 'F')
4682 return a
- 'A' + 10;
4684 error (_("Reply contains invalid hex digit %d"), a
);
4688 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
4692 for (i
= 0; i
< count
; i
++)
4694 if (hex
[0] == 0 || hex
[1] == 0)
4696 /* Hex string is short, or of uneven length.
4697 Return the count that has been converted so far. */
4700 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
4706 /* Convert number NIB to a hex digit. */
4714 return 'a' + nib
- 10;
4718 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
4722 /* May use a length, or a nul-terminated string as input. */
4724 count
= strlen ((char *) bin
);
4726 for (i
= 0; i
< count
; i
++)
4728 *hex
++ = tohex ((*bin
>> 4) & 0xf);
4729 *hex
++ = tohex (*bin
++ & 0xf);
4735 /* Check for the availability of vCont. This function should also check
4739 remote_vcont_probe (struct remote_state
*rs
)
4743 strcpy (rs
->buf
, "vCont?");
4745 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4748 /* Make sure that the features we assume are supported. */
4749 if (strncmp (buf
, "vCont", 5) == 0)
4752 int support_s
, support_S
, support_c
, support_C
;
4758 rs
->supports_vCont
.t
= 0;
4759 rs
->supports_vCont
.r
= 0;
4760 while (p
&& *p
== ';')
4763 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4765 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4767 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4769 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4771 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4772 rs
->supports_vCont
.t
= 1;
4773 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4774 rs
->supports_vCont
.r
= 1;
4776 p
= strchr (p
, ';');
4779 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
4780 BUF will make packet_ok disable the packet. */
4781 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
4785 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
4788 /* Helper function for building "vCont" resumptions. Write a
4789 resumption to P. ENDP points to one-passed-the-end of the buffer
4790 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
4791 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
4792 resumed thread should be single-stepped and/or signalled. If PTID
4793 equals minus_one_ptid, then all threads are resumed; if PTID
4794 represents a process, then all threads of the process are resumed;
4795 the thread to be stepped and/or signalled is given in the global
4799 append_resumption (char *p
, char *endp
,
4800 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
4802 struct remote_state
*rs
= get_remote_state ();
4804 if (step
&& siggnal
!= GDB_SIGNAL_0
)
4805 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
4807 /* GDB is willing to range step. */
4808 && use_range_stepping
4809 /* Target supports range stepping. */
4810 && rs
->supports_vCont
.r
4811 /* We don't currently support range stepping multiple
4812 threads with a wildcard (though the protocol allows it,
4813 so stubs shouldn't make an active effort to forbid
4815 && !(remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
4817 struct thread_info
*tp
;
4819 if (ptid_equal (ptid
, minus_one_ptid
))
4821 /* If we don't know about the target thread's tid, then
4822 we're resuming magic_null_ptid (see caller). */
4823 tp
= find_thread_ptid (magic_null_ptid
);
4826 tp
= find_thread_ptid (ptid
);
4827 gdb_assert (tp
!= NULL
);
4829 if (tp
->control
.may_range_step
)
4831 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4833 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
4834 phex_nz (tp
->control
.step_range_start
,
4836 phex_nz (tp
->control
.step_range_end
,
4840 p
+= xsnprintf (p
, endp
- p
, ";s");
4843 p
+= xsnprintf (p
, endp
- p
, ";s");
4844 else if (siggnal
!= GDB_SIGNAL_0
)
4845 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
4847 p
+= xsnprintf (p
, endp
- p
, ";c");
4849 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
4853 /* All (-1) threads of process. */
4854 nptid
= ptid_build (ptid_get_pid (ptid
), 0, -1);
4856 p
+= xsnprintf (p
, endp
- p
, ":");
4857 p
= write_ptid (p
, endp
, nptid
);
4859 else if (!ptid_equal (ptid
, minus_one_ptid
))
4861 p
+= xsnprintf (p
, endp
- p
, ":");
4862 p
= write_ptid (p
, endp
, ptid
);
4868 /* Append a vCont continue-with-signal action for threads that have a
4869 non-zero stop signal. */
4872 append_pending_thread_resumptions (char *p
, char *endp
, ptid_t ptid
)
4874 struct thread_info
*thread
;
4876 ALL_THREADS (thread
)
4877 if (ptid_match (thread
->ptid
, ptid
)
4878 && !ptid_equal (inferior_ptid
, thread
->ptid
)
4879 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
4880 && signal_pass_state (thread
->suspend
.stop_signal
))
4882 p
= append_resumption (p
, endp
, thread
->ptid
,
4883 0, thread
->suspend
.stop_signal
);
4884 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4890 /* Resume the remote inferior by using a "vCont" packet. The thread
4891 to be resumed is PTID; STEP and SIGGNAL indicate whether the
4892 resumed thread should be single-stepped and/or signalled. If PTID
4893 equals minus_one_ptid, then all threads are resumed; the thread to
4894 be stepped and/or signalled is given in the global INFERIOR_PTID.
4895 This function returns non-zero iff it resumes the inferior.
4897 This function issues a strict subset of all possible vCont commands at the
4901 remote_vcont_resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
4903 struct remote_state
*rs
= get_remote_state ();
4907 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
4908 remote_vcont_probe (rs
);
4910 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
4914 endp
= rs
->buf
+ get_remote_packet_size ();
4916 /* If we could generate a wider range of packets, we'd have to worry
4917 about overflowing BUF. Should there be a generic
4918 "multi-part-packet" packet? */
4920 p
+= xsnprintf (p
, endp
- p
, "vCont");
4922 if (ptid_equal (ptid
, magic_null_ptid
))
4924 /* MAGIC_NULL_PTID means that we don't have any active threads,
4925 so we don't have any TID numbers the inferior will
4926 understand. Make sure to only send forms that do not specify
4928 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
4930 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
4932 /* Resume all threads (of all processes, or of a single
4933 process), with preference for INFERIOR_PTID. This assumes
4934 inferior_ptid belongs to the set of all threads we are about
4936 if (step
|| siggnal
!= GDB_SIGNAL_0
)
4938 /* Step inferior_ptid, with or without signal. */
4939 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
4942 /* Also pass down any pending signaled resumption for other
4943 threads not the current. */
4944 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
4946 /* And continue others without a signal. */
4947 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
4951 /* Scheduler locking; resume only PTID. */
4952 append_resumption (p
, endp
, ptid
, step
, siggnal
);
4955 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
4960 /* In non-stop, the stub replies to vCont with "OK". The stop
4961 reply will be reported asynchronously by means of a `%Stop'
4963 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4964 if (strcmp (rs
->buf
, "OK") != 0)
4965 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
4971 /* Tell the remote machine to resume. */
4974 remote_resume (struct target_ops
*ops
,
4975 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
4977 struct remote_state
*rs
= get_remote_state ();
4980 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
4981 (explained in remote-notif.c:handle_notification) so
4982 remote_notif_process is not called. We need find a place where
4983 it is safe to start a 'vNotif' sequence. It is good to do it
4984 before resuming inferior, because inferior was stopped and no RSP
4985 traffic at that moment. */
4987 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
4989 rs
->last_sent_signal
= siggnal
;
4990 rs
->last_sent_step
= step
;
4992 /* The vCont packet doesn't need to specify threads via Hc. */
4993 /* No reverse support (yet) for vCont. */
4994 if (execution_direction
!= EXEC_REVERSE
)
4995 if (remote_vcont_resume (ptid
, step
, siggnal
))
4998 /* All other supported resume packets do use Hc, so set the continue
5000 if (ptid_equal (ptid
, minus_one_ptid
))
5001 set_continue_thread (any_thread_ptid
);
5003 set_continue_thread (ptid
);
5006 if (execution_direction
== EXEC_REVERSE
)
5008 /* We don't pass signals to the target in reverse exec mode. */
5009 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
5010 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5014 && remote_protocol_packets
[PACKET_bs
].support
== PACKET_DISABLE
)
5015 error (_("Remote reverse-step not supported."));
5017 && remote_protocol_packets
[PACKET_bc
].support
== PACKET_DISABLE
)
5018 error (_("Remote reverse-continue not supported."));
5020 strcpy (buf
, step
? "bs" : "bc");
5022 else if (siggnal
!= GDB_SIGNAL_0
)
5024 buf
[0] = step
? 'S' : 'C';
5025 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
5026 buf
[2] = tohex (((int) siggnal
) & 0xf);
5030 strcpy (buf
, step
? "s" : "c");
5035 /* We are about to start executing the inferior, let's register it
5036 with the event loop. NOTE: this is the one place where all the
5037 execution commands end up. We could alternatively do this in each
5038 of the execution commands in infcmd.c. */
5039 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5040 into infcmd.c in order to allow inferior function calls to work
5041 NOT asynchronously. */
5042 if (target_can_async_p ())
5043 target_async (inferior_event_handler
, 0);
5045 /* We've just told the target to resume. The remote server will
5046 wait for the inferior to stop, and then send a stop reply. In
5047 the mean time, we can't start another command/query ourselves
5048 because the stub wouldn't be ready to process it. This applies
5049 only to the base all-stop protocol, however. In non-stop (which
5050 only supports vCont), the stub replies with an "OK", and is
5051 immediate able to process further serial input. */
5053 rs
->waiting_for_stop_reply
= 1;
5057 /* Set up the signal handler for SIGINT, while the target is
5058 executing, ovewriting the 'regular' SIGINT signal handler. */
5060 async_initialize_sigint_signal_handler (void)
5062 signal (SIGINT
, async_handle_remote_sigint
);
5065 /* Signal handler for SIGINT, while the target is executing. */
5067 async_handle_remote_sigint (int sig
)
5069 signal (sig
, async_handle_remote_sigint_twice
);
5070 mark_async_signal_handler (async_sigint_remote_token
);
5073 /* Signal handler for SIGINT, installed after SIGINT has already been
5074 sent once. It will take effect the second time that the user sends
5077 async_handle_remote_sigint_twice (int sig
)
5079 signal (sig
, async_handle_remote_sigint
);
5080 mark_async_signal_handler (async_sigint_remote_twice_token
);
5083 /* Perform the real interruption of the target execution, in response
5086 async_remote_interrupt (gdb_client_data arg
)
5089 fprintf_unfiltered (gdb_stdlog
, "async_remote_interrupt called\n");
5091 target_stop (inferior_ptid
);
5094 /* Perform interrupt, if the first attempt did not succeed. Just give
5095 up on the target alltogether. */
5097 async_remote_interrupt_twice (gdb_client_data arg
)
5100 fprintf_unfiltered (gdb_stdlog
, "async_remote_interrupt_twice called\n");
5105 /* Reinstall the usual SIGINT handlers, after the target has
5108 async_cleanup_sigint_signal_handler (void *dummy
)
5110 signal (SIGINT
, handle_sigint
);
5113 /* Send ^C to target to halt it. Target will respond, and send us a
5115 static void (*ofunc
) (int);
5117 /* The command line interface's stop routine. This function is installed
5118 as a signal handler for SIGINT. The first time a user requests a
5119 stop, we call remote_stop to send a break or ^C. If there is no
5120 response from the target (it didn't stop when the user requested it),
5121 we ask the user if he'd like to detach from the target. */
5123 sync_remote_interrupt (int signo
)
5125 /* If this doesn't work, try more severe steps. */
5126 signal (signo
, sync_remote_interrupt_twice
);
5128 gdb_call_async_signal_handler (async_sigint_remote_token
, 1);
5131 /* The user typed ^C twice. */
5134 sync_remote_interrupt_twice (int signo
)
5136 signal (signo
, ofunc
);
5137 gdb_call_async_signal_handler (async_sigint_remote_twice_token
, 1);
5138 signal (signo
, sync_remote_interrupt
);
5141 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
5142 thread, all threads of a remote process, or all threads of all
5146 remote_stop_ns (ptid_t ptid
)
5148 struct remote_state
*rs
= get_remote_state ();
5150 char *endp
= rs
->buf
+ get_remote_packet_size ();
5152 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
5153 remote_vcont_probe (rs
);
5155 if (!rs
->supports_vCont
.t
)
5156 error (_("Remote server does not support stopping threads"));
5158 if (ptid_equal (ptid
, minus_one_ptid
)
5159 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
5160 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
5165 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
5167 if (ptid_is_pid (ptid
))
5168 /* All (-1) threads of process. */
5169 nptid
= ptid_build (ptid_get_pid (ptid
), 0, -1);
5172 /* Small optimization: if we already have a stop reply for
5173 this thread, no use in telling the stub we want this
5175 if (peek_stop_reply (ptid
))
5181 write_ptid (p
, endp
, nptid
);
5184 /* In non-stop, we get an immediate OK reply. The stop reply will
5185 come in asynchronously by notification. */
5187 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5188 if (strcmp (rs
->buf
, "OK") != 0)
5189 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
5192 /* All-stop version of target_stop. Sends a break or a ^C to stop the
5193 remote target. It is undefined which thread of which process
5194 reports the stop. */
5197 remote_stop_as (ptid_t ptid
)
5199 struct remote_state
*rs
= get_remote_state ();
5201 rs
->ctrlc_pending_p
= 1;
5203 /* If the inferior is stopped already, but the core didn't know
5204 about it yet, just ignore the request. The cached wait status
5205 will be collected in remote_wait. */
5206 if (rs
->cached_wait_status
)
5209 /* Send interrupt_sequence to remote target. */
5210 send_interrupt_sequence ();
5213 /* This is the generic stop called via the target vector. When a target
5214 interrupt is requested, either by the command line or the GUI, we
5215 will eventually end up here. */
5218 remote_stop (ptid_t ptid
)
5221 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
5224 remote_stop_ns (ptid
);
5226 remote_stop_as (ptid
);
5229 /* Ask the user what to do when an interrupt is received. */
5232 interrupt_query (void)
5234 target_terminal_ours ();
5236 if (target_can_async_p ())
5238 signal (SIGINT
, handle_sigint
);
5243 if (query (_("Interrupted while waiting for the program.\n\
5244 Give up (and stop debugging it)? ")))
5246 remote_unpush_target ();
5251 target_terminal_inferior ();
5254 /* Enable/disable target terminal ownership. Most targets can use
5255 terminal groups to control terminal ownership. Remote targets are
5256 different in that explicit transfer of ownership to/from GDB/target
5260 remote_terminal_inferior (void)
5262 if (!target_async_permitted
)
5263 /* Nothing to do. */
5266 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
5267 idempotent. The event-loop GDB talking to an asynchronous target
5268 with a synchronous command calls this function from both
5269 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
5270 transfer the terminal to the target when it shouldn't this guard
5272 if (!remote_async_terminal_ours_p
)
5274 delete_file_handler (input_fd
);
5275 remote_async_terminal_ours_p
= 0;
5276 async_initialize_sigint_signal_handler ();
5277 /* NOTE: At this point we could also register our selves as the
5278 recipient of all input. Any characters typed could then be
5279 passed on down to the target. */
5283 remote_terminal_ours (void)
5285 if (!target_async_permitted
)
5286 /* Nothing to do. */
5289 /* See FIXME in remote_terminal_inferior. */
5290 if (remote_async_terminal_ours_p
)
5292 async_cleanup_sigint_signal_handler (NULL
);
5293 add_file_handler (input_fd
, stdin_event_handler
, 0);
5294 remote_async_terminal_ours_p
= 1;
5298 remote_console_output (char *msg
)
5302 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
5305 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
5309 fputs_unfiltered (tb
, gdb_stdtarg
);
5311 gdb_flush (gdb_stdtarg
);
5314 typedef struct cached_reg
5317 gdb_byte data
[MAX_REGISTER_SIZE
];
5320 DEF_VEC_O(cached_reg_t
);
5322 typedef struct stop_reply
5324 struct notif_event base
;
5326 /* The identifier of the thread about this event */
5329 /* The remote state this event is associated with. When the remote
5330 connection, represented by a remote_state object, is closed,
5331 all the associated stop_reply events should be released. */
5332 struct remote_state
*rs
;
5334 struct target_waitstatus ws
;
5336 /* Expedited registers. This makes remote debugging a bit more
5337 efficient for those targets that provide critical registers as
5338 part of their normal status mechanism (as another roundtrip to
5339 fetch them is avoided). */
5340 VEC(cached_reg_t
) *regcache
;
5342 int stopped_by_watchpoint_p
;
5343 CORE_ADDR watch_data_address
;
5348 DECLARE_QUEUE_P (stop_reply_p
);
5349 DEFINE_QUEUE_P (stop_reply_p
);
5350 /* The list of already fetched and acknowledged stop events. This
5351 queue is used for notification Stop, and other notifications
5352 don't need queue for their events, because the notification events
5353 of Stop can't be consumed immediately, so that events should be
5354 queued first, and be consumed by remote_wait_{ns,as} one per
5355 time. Other notifications can consume their events immediately,
5356 so queue is not needed for them. */
5357 static QUEUE (stop_reply_p
) *stop_reply_queue
;
5360 stop_reply_xfree (struct stop_reply
*r
)
5362 notif_event_xfree ((struct notif_event
*) r
);
5366 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
5367 struct notif_event
*event
)
5369 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
5373 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
5374 struct notif_event
*event
)
5376 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
5379 putpkt ((char *) self
->ack_command
);
5381 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
5382 /* We got an unknown stop reply. */
5383 error (_("Unknown stop reply"));
5385 push_stop_reply (stop_reply
);
5389 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
5391 /* We can't get pending events in remote_notif_process for
5392 notification stop, and we have to do this in remote_wait_ns
5393 instead. If we fetch all queued events from stub, remote stub
5394 may exit and we have no chance to process them back in
5396 mark_async_event_handler (remote_async_inferior_event_token
);
5401 stop_reply_dtr (struct notif_event
*event
)
5403 struct stop_reply
*r
= (struct stop_reply
*) event
;
5405 VEC_free (cached_reg_t
, r
->regcache
);
5408 static struct notif_event
*
5409 remote_notif_stop_alloc_reply (void)
5411 struct notif_event
*r
5412 = (struct notif_event
*) XNEW (struct stop_reply
);
5414 r
->dtr
= stop_reply_dtr
;
5419 /* A client of notification Stop. */
5421 struct notif_client notif_client_stop
=
5425 remote_notif_stop_parse
,
5426 remote_notif_stop_ack
,
5427 remote_notif_stop_can_get_pending_events
,
5428 remote_notif_stop_alloc_reply
,
5432 /* A parameter to pass data in and out. */
5434 struct queue_iter_param
5437 struct stop_reply
*output
;
5440 /* Remove stop replies in the queue if its pid is equal to the given
5444 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
5445 QUEUE_ITER (stop_reply_p
) *iter
,
5449 struct queue_iter_param
*param
= data
;
5450 struct inferior
*inf
= param
->input
;
5452 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
5454 stop_reply_xfree (event
);
5455 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
5461 /* Discard all pending stop replies of inferior INF. */
5464 discard_pending_stop_replies (struct inferior
*inf
)
5467 struct queue_iter_param param
;
5468 struct stop_reply
*reply
;
5469 struct remote_state
*rs
= get_remote_state ();
5470 struct remote_notif_state
*rns
= rs
->notif_state
;
5472 /* This function can be notified when an inferior exists. When the
5473 target is not remote, the notification state is NULL. */
5474 if (rs
->remote_desc
== NULL
)
5477 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
5479 /* Discard the in-flight notification. */
5480 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
5482 stop_reply_xfree (reply
);
5483 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
5487 param
.output
= NULL
;
5488 /* Discard the stop replies we have already pulled with
5490 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5491 remove_stop_reply_for_inferior
, ¶m
);
5494 /* If its remote state is equal to the given remote state,
5495 remove EVENT from the stop reply queue. */
5498 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
5499 QUEUE_ITER (stop_reply_p
) *iter
,
5503 struct queue_iter_param
*param
= data
;
5504 struct remote_state
*rs
= param
->input
;
5506 if (event
->rs
== rs
)
5508 stop_reply_xfree (event
);
5509 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
5515 /* Discard the stop replies for RS in stop_reply_queue. */
5518 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
5520 struct queue_iter_param param
;
5523 param
.output
= NULL
;
5524 /* Discard the stop replies we have already pulled with
5526 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5527 remove_stop_reply_of_remote_state
, ¶m
);
5530 /* A parameter to pass data in and out. */
5533 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
5534 QUEUE_ITER (stop_reply_p
) *iter
,
5538 struct queue_iter_param
*param
= data
;
5539 ptid_t
*ptid
= param
->input
;
5541 if (ptid_match (event
->ptid
, *ptid
))
5543 param
->output
= event
;
5544 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
5551 /* Remove the first reply in 'stop_reply_queue' which matches
5554 static struct stop_reply
*
5555 remote_notif_remove_queued_reply (ptid_t ptid
)
5557 struct queue_iter_param param
;
5559 param
.input
= &ptid
;
5560 param
.output
= NULL
;
5562 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5563 remote_notif_remove_once_on_match
, ¶m
);
5565 fprintf_unfiltered (gdb_stdlog
,
5566 "notif: discard queued event: 'Stop' in %s\n",
5567 target_pid_to_str (ptid
));
5569 return param
.output
;
5572 /* Look for a queued stop reply belonging to PTID. If one is found,
5573 remove it from the queue, and return it. Returns NULL if none is
5574 found. If there are still queued events left to process, tell the
5575 event loop to get back to target_wait soon. */
5577 static struct stop_reply
*
5578 queued_stop_reply (ptid_t ptid
)
5580 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
5582 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
5583 /* There's still at least an event left. */
5584 mark_async_event_handler (remote_async_inferior_event_token
);
5589 /* Push a fully parsed stop reply in the stop reply queue. Since we
5590 know that we now have at least one queued event left to pass to the
5591 core side, tell the event loop to get back to target_wait soon. */
5594 push_stop_reply (struct stop_reply
*new_event
)
5596 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
5599 fprintf_unfiltered (gdb_stdlog
,
5600 "notif: push 'Stop' %s to queue %d\n",
5601 target_pid_to_str (new_event
->ptid
),
5602 QUEUE_length (stop_reply_p
,
5605 mark_async_event_handler (remote_async_inferior_event_token
);
5609 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
5610 QUEUE_ITER (stop_reply_p
) *iter
,
5611 struct stop_reply
*event
,
5614 ptid_t
*ptid
= data
;
5616 return !(ptid_equal (*ptid
, event
->ptid
)
5617 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5620 /* Returns true if we have a stop reply for PTID. */
5623 peek_stop_reply (ptid_t ptid
)
5625 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
5626 stop_reply_match_ptid_and_ws
, &ptid
);
5629 /* Parse the stop reply in BUF. Either the function succeeds, and the
5630 result is stored in EVENT, or throws an error. */
5633 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
5635 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5639 event
->ptid
= null_ptid
;
5640 event
->rs
= get_remote_state ();
5641 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
5642 event
->ws
.value
.integer
= 0;
5643 event
->stopped_by_watchpoint_p
= 0;
5644 event
->regcache
= NULL
;
5649 case 'T': /* Status with PC, SP, FP, ... */
5650 /* Expedited reply, containing Signal, {regno, reg} repeat. */
5651 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
5653 n... = register number
5654 r... = register contents
5657 p
= &buf
[3]; /* after Txx */
5665 /* If the packet contains a register number, save it in
5666 pnum and set p1 to point to the character following it.
5667 Otherwise p1 points to p. */
5669 /* If this packet is an awatch packet, don't parse the 'a'
5670 as a register number. */
5672 if (strncmp (p
, "awatch", strlen("awatch")) != 0
5673 && strncmp (p
, "core", strlen ("core") != 0))
5675 /* Read the ``P'' register number. */
5676 pnum
= strtol (p
, &p_temp
, 16);
5682 if (p1
== p
) /* No register number present here. */
5684 p1
= strchr (p
, ':');
5686 error (_("Malformed packet(a) (missing colon): %s\n\
5689 if (strncmp (p
, "thread", p1
- p
) == 0)
5690 event
->ptid
= read_ptid (++p1
, &p
);
5691 else if ((strncmp (p
, "watch", p1
- p
) == 0)
5692 || (strncmp (p
, "rwatch", p1
- p
) == 0)
5693 || (strncmp (p
, "awatch", p1
- p
) == 0))
5695 event
->stopped_by_watchpoint_p
= 1;
5696 p
= unpack_varlen_hex (++p1
, &addr
);
5697 event
->watch_data_address
= (CORE_ADDR
) addr
;
5699 else if (strncmp (p
, "library", p1
- p
) == 0)
5703 while (*p_temp
&& *p_temp
!= ';')
5706 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
5709 else if (strncmp (p
, "replaylog", p1
- p
) == 0)
5711 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
5712 /* p1 will indicate "begin" or "end", but it makes
5713 no difference for now, so ignore it. */
5714 p_temp
= strchr (p1
+ 1, ';');
5718 else if (strncmp (p
, "core", p1
- p
) == 0)
5722 p
= unpack_varlen_hex (++p1
, &c
);
5727 /* Silently skip unknown optional info. */
5728 p_temp
= strchr (p1
+ 1, ';');
5735 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
5736 cached_reg_t cached_reg
;
5741 error (_("Malformed packet(b) (missing colon): %s\n\
5747 error (_("Remote sent bad register number %s: %s\n\
5749 hex_string (pnum
), p
, buf
);
5751 cached_reg
.num
= reg
->regnum
;
5753 fieldsize
= hex2bin (p
, cached_reg
.data
,
5754 register_size (target_gdbarch (),
5757 if (fieldsize
< register_size (target_gdbarch (),
5759 warning (_("Remote reply is too short: %s"), buf
);
5761 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
5765 error (_("Remote register badly formatted: %s\nhere: %s"),
5770 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
5774 case 'S': /* Old style status, just signal only. */
5778 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
5779 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
5780 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
5781 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
5783 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
5786 case 'W': /* Target exited. */
5793 /* GDB used to accept only 2 hex chars here. Stubs should
5794 only send more if they detect GDB supports multi-process
5796 p
= unpack_varlen_hex (&buf
[1], &value
);
5800 /* The remote process exited. */
5801 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
5802 event
->ws
.value
.integer
= value
;
5806 /* The remote process exited with a signal. */
5807 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
5808 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
5809 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
5811 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
5814 /* If no process is specified, assume inferior_ptid. */
5815 pid
= ptid_get_pid (inferior_ptid
);
5824 else if (strncmp (p
,
5825 "process:", sizeof ("process:") - 1) == 0)
5829 p
+= sizeof ("process:") - 1;
5830 unpack_varlen_hex (p
, &upid
);
5834 error (_("unknown stop reply packet: %s"), buf
);
5837 error (_("unknown stop reply packet: %s"), buf
);
5838 event
->ptid
= pid_to_ptid (pid
);
5843 if (non_stop
&& ptid_equal (event
->ptid
, null_ptid
))
5844 error (_("No process or thread specified in stop reply: %s"), buf
);
5847 /* When the stub wants to tell GDB about a new notification reply, it
5848 sends a notification (%Stop, for example). Those can come it at
5849 any time, hence, we have to make sure that any pending
5850 putpkt/getpkt sequence we're making is finished, before querying
5851 the stub for more events with the corresponding ack command
5852 (vStopped, for example). E.g., if we started a vStopped sequence
5853 immediately upon receiving the notification, something like this
5861 1.6) <-- (registers reply to step #1.3)
5863 Obviously, the reply in step #1.6 would be unexpected to a vStopped
5866 To solve this, whenever we parse a %Stop notification successfully,
5867 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
5868 doing whatever we were doing:
5874 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
5875 2.5) <-- (registers reply to step #2.3)
5877 Eventualy after step #2.5, we return to the event loop, which
5878 notices there's an event on the
5879 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
5880 associated callback --- the function below. At this point, we're
5881 always safe to start a vStopped sequence. :
5884 2.7) <-- T05 thread:2
5890 remote_notif_get_pending_events (struct notif_client
*nc
)
5892 struct remote_state
*rs
= get_remote_state ();
5894 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
5897 fprintf_unfiltered (gdb_stdlog
,
5898 "notif: process: '%s' ack pending event\n",
5902 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
5903 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
5907 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5908 if (strcmp (rs
->buf
, "OK") == 0)
5911 remote_notif_ack (nc
, rs
->buf
);
5917 fprintf_unfiltered (gdb_stdlog
,
5918 "notif: process: '%s' no pending reply\n",
5923 /* Called when it is decided that STOP_REPLY holds the info of the
5924 event that is to be returned to the core. This function always
5925 destroys STOP_REPLY. */
5928 process_stop_reply (struct stop_reply
*stop_reply
,
5929 struct target_waitstatus
*status
)
5933 *status
= stop_reply
->ws
;
5934 ptid
= stop_reply
->ptid
;
5936 /* If no thread/process was reported by the stub, assume the current
5938 if (ptid_equal (ptid
, null_ptid
))
5939 ptid
= inferior_ptid
;
5941 if (status
->kind
!= TARGET_WAITKIND_EXITED
5942 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
5944 struct remote_state
*rs
= get_remote_state ();
5946 /* Expedited registers. */
5947 if (stop_reply
->regcache
)
5949 struct regcache
*regcache
5950 = get_thread_arch_regcache (ptid
, target_gdbarch ());
5955 VEC_iterate(cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
5957 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
5958 VEC_free (cached_reg_t
, stop_reply
->regcache
);
5961 rs
->remote_stopped_by_watchpoint_p
= stop_reply
->stopped_by_watchpoint_p
;
5962 rs
->remote_watch_data_address
= stop_reply
->watch_data_address
;
5964 remote_notice_new_inferior (ptid
, 0);
5965 demand_private_info (ptid
)->core
= stop_reply
->core
;
5968 stop_reply_xfree (stop_reply
);
5972 /* The non-stop mode version of target_wait. */
5975 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5977 struct remote_state
*rs
= get_remote_state ();
5978 struct stop_reply
*stop_reply
;
5982 /* If in non-stop mode, get out of getpkt even if a
5983 notification is received. */
5985 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
5986 0 /* forever */, &is_notif
);
5989 if (ret
!= -1 && !is_notif
)
5992 case 'E': /* Error of some sort. */
5993 /* We're out of sync with the target now. Did it continue
5994 or not? We can't tell which thread it was in non-stop,
5995 so just ignore this. */
5996 warning (_("Remote failure reply: %s"), rs
->buf
);
5998 case 'O': /* Console output. */
5999 remote_console_output (rs
->buf
+ 1);
6002 warning (_("Invalid remote reply: %s"), rs
->buf
);
6006 /* Acknowledge a pending stop reply that may have arrived in the
6008 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
6009 remote_notif_get_pending_events (¬if_client_stop
);
6011 /* If indeed we noticed a stop reply, we're done. */
6012 stop_reply
= queued_stop_reply (ptid
);
6013 if (stop_reply
!= NULL
)
6014 return process_stop_reply (stop_reply
, status
);
6016 /* Still no event. If we're just polling for an event, then
6017 return to the event loop. */
6018 if (options
& TARGET_WNOHANG
)
6020 status
->kind
= TARGET_WAITKIND_IGNORE
;
6021 return minus_one_ptid
;
6024 /* Otherwise do a blocking wait. */
6025 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
6026 1 /* forever */, &is_notif
);
6030 /* Wait until the remote machine stops, then return, storing status in
6031 STATUS just as `wait' would. */
6034 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
6036 struct remote_state
*rs
= get_remote_state ();
6037 ptid_t event_ptid
= null_ptid
;
6039 struct stop_reply
*stop_reply
;
6043 status
->kind
= TARGET_WAITKIND_IGNORE
;
6044 status
->value
.integer
= 0;
6046 stop_reply
= queued_stop_reply (ptid
);
6047 if (stop_reply
!= NULL
)
6048 return process_stop_reply (stop_reply
, status
);
6050 if (rs
->cached_wait_status
)
6051 /* Use the cached wait status, but only once. */
6052 rs
->cached_wait_status
= 0;
6058 if (!target_is_async_p ())
6060 ofunc
= signal (SIGINT
, sync_remote_interrupt
);
6061 /* If the user hit C-c before this packet, or between packets,
6062 pretend that it was hit right here. */
6063 if (check_quit_flag ())
6066 sync_remote_interrupt (SIGINT
);
6070 /* FIXME: cagney/1999-09-27: If we're in async mode we should
6071 _never_ wait for ever -> test on target_is_async_p().
6072 However, before we do that we need to ensure that the caller
6073 knows how to take the target into/out of async mode. */
6074 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
6075 wait_forever_enabled_p
, &is_notif
);
6077 if (!target_is_async_p ())
6078 signal (SIGINT
, ofunc
);
6080 /* GDB gets a notification. Return to core as this event is
6082 if (ret
!= -1 && is_notif
)
6083 return minus_one_ptid
;
6088 rs
->remote_stopped_by_watchpoint_p
= 0;
6090 /* We got something. */
6091 rs
->waiting_for_stop_reply
= 0;
6093 /* Assume that the target has acknowledged Ctrl-C unless we receive
6094 an 'F' or 'O' packet. */
6095 if (buf
[0] != 'F' && buf
[0] != 'O')
6096 rs
->ctrlc_pending_p
= 0;
6100 case 'E': /* Error of some sort. */
6101 /* We're out of sync with the target now. Did it continue or
6102 not? Not is more likely, so report a stop. */
6103 warning (_("Remote failure reply: %s"), buf
);
6104 status
->kind
= TARGET_WAITKIND_STOPPED
;
6105 status
->value
.sig
= GDB_SIGNAL_0
;
6107 case 'F': /* File-I/O request. */
6108 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
6109 rs
->ctrlc_pending_p
= 0;
6111 case 'T': case 'S': case 'X': case 'W':
6113 struct stop_reply
*stop_reply
6114 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
6117 event_ptid
= process_stop_reply (stop_reply
, status
);
6120 case 'O': /* Console output. */
6121 remote_console_output (buf
+ 1);
6123 /* The target didn't really stop; keep waiting. */
6124 rs
->waiting_for_stop_reply
= 1;
6128 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
6130 /* Zero length reply means that we tried 'S' or 'C' and the
6131 remote system doesn't support it. */
6132 target_terminal_ours_for_output ();
6134 ("Can't send signals to this remote system. %s not sent.\n",
6135 gdb_signal_to_name (rs
->last_sent_signal
));
6136 rs
->last_sent_signal
= GDB_SIGNAL_0
;
6137 target_terminal_inferior ();
6139 strcpy ((char *) buf
, rs
->last_sent_step
? "s" : "c");
6140 putpkt ((char *) buf
);
6142 /* We just told the target to resume, so a stop reply is in
6144 rs
->waiting_for_stop_reply
= 1;
6147 /* else fallthrough */
6149 warning (_("Invalid remote reply: %s"), buf
);
6151 rs
->waiting_for_stop_reply
= 1;
6155 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
6157 /* Nothing interesting happened. If we're doing a non-blocking
6158 poll, we're done. Otherwise, go back to waiting. */
6159 if (options
& TARGET_WNOHANG
)
6160 return minus_one_ptid
;
6164 else if (status
->kind
!= TARGET_WAITKIND_EXITED
6165 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
6167 if (!ptid_equal (event_ptid
, null_ptid
))
6168 record_currthread (rs
, event_ptid
);
6170 event_ptid
= inferior_ptid
;
6173 /* A process exit. Invalidate our notion of current thread. */
6174 record_currthread (rs
, minus_one_ptid
);
6179 /* Wait until the remote machine stops, then return, storing status in
6180 STATUS just as `wait' would. */
6183 remote_wait (struct target_ops
*ops
,
6184 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
6189 event_ptid
= remote_wait_ns (ptid
, status
, options
);
6191 event_ptid
= remote_wait_as (ptid
, status
, options
);
6193 if (target_can_async_p ())
6195 /* If there are are events left in the queue tell the event loop
6197 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6198 mark_async_event_handler (remote_async_inferior_event_token
);
6204 /* Fetch a single register using a 'p' packet. */
6207 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
6209 struct remote_state
*rs
= get_remote_state ();
6211 char regp
[MAX_REGISTER_SIZE
];
6214 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
6217 if (reg
->pnum
== -1)
6222 p
+= hexnumstr (p
, reg
->pnum
);
6225 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6229 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
6233 case PACKET_UNKNOWN
:
6236 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
6237 gdbarch_register_name (get_regcache_arch (regcache
),
6242 /* If this register is unfetchable, tell the regcache. */
6245 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
6249 /* Otherwise, parse and supply the value. */
6255 error (_("fetch_register_using_p: early buf termination"));
6257 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
6260 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
6264 /* Fetch the registers included in the target's 'g' packet. */
6267 send_g_packet (void)
6269 struct remote_state
*rs
= get_remote_state ();
6272 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
6273 remote_send (&rs
->buf
, &rs
->buf_size
);
6275 /* We can get out of synch in various cases. If the first character
6276 in the buffer is not a hex character, assume that has happened
6277 and try to fetch another packet to read. */
6278 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
6279 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
6280 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
6281 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
6284 fprintf_unfiltered (gdb_stdlog
,
6285 "Bad register packet; fetching a new packet\n");
6286 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6289 buf_len
= strlen (rs
->buf
);
6291 /* Sanity check the received packet. */
6292 if (buf_len
% 2 != 0)
6293 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
6299 process_g_packet (struct regcache
*regcache
)
6301 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
6302 struct remote_state
*rs
= get_remote_state ();
6303 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6308 buf_len
= strlen (rs
->buf
);
6310 /* Further sanity checks, with knowledge of the architecture. */
6311 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
6312 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
6314 /* Save the size of the packet sent to us by the target. It is used
6315 as a heuristic when determining the max size of packets that the
6316 target can safely receive. */
6317 if (rsa
->actual_register_packet_size
== 0)
6318 rsa
->actual_register_packet_size
= buf_len
;
6320 /* If this is smaller than we guessed the 'g' packet would be,
6321 update our records. A 'g' reply that doesn't include a register's
6322 value implies either that the register is not available, or that
6323 the 'p' packet must be used. */
6324 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
6326 rsa
->sizeof_g_packet
= buf_len
/ 2;
6328 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
6330 if (rsa
->regs
[i
].pnum
== -1)
6333 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
6334 rsa
->regs
[i
].in_g_packet
= 0;
6336 rsa
->regs
[i
].in_g_packet
= 1;
6340 regs
= alloca (rsa
->sizeof_g_packet
);
6342 /* Unimplemented registers read as all bits zero. */
6343 memset (regs
, 0, rsa
->sizeof_g_packet
);
6345 /* Reply describes registers byte by byte, each byte encoded as two
6346 hex characters. Suck them all up, then supply them to the
6347 register cacheing/storage mechanism. */
6350 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
6352 if (p
[0] == 0 || p
[1] == 0)
6353 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
6354 internal_error (__FILE__
, __LINE__
,
6355 _("unexpected end of 'g' packet reply"));
6357 if (p
[0] == 'x' && p
[1] == 'x')
6358 regs
[i
] = 0; /* 'x' */
6360 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
6364 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
6366 struct packet_reg
*r
= &rsa
->regs
[i
];
6370 if (r
->offset
* 2 >= strlen (rs
->buf
))
6371 /* This shouldn't happen - we adjusted in_g_packet above. */
6372 internal_error (__FILE__
, __LINE__
,
6373 _("unexpected end of 'g' packet reply"));
6374 else if (rs
->buf
[r
->offset
* 2] == 'x')
6376 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
6377 /* The register isn't available, mark it as such (at
6378 the same time setting the value to zero). */
6379 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
6382 regcache_raw_supply (regcache
, r
->regnum
,
6389 fetch_registers_using_g (struct regcache
*regcache
)
6392 process_g_packet (regcache
);
6395 /* Make the remote selected traceframe match GDB's selected
6399 set_remote_traceframe (void)
6402 struct remote_state
*rs
= get_remote_state ();
6404 if (rs
->remote_traceframe_number
== get_traceframe_number ())
6407 /* Avoid recursion, remote_trace_find calls us again. */
6408 rs
->remote_traceframe_number
= get_traceframe_number ();
6410 newnum
= target_trace_find (tfind_number
,
6411 get_traceframe_number (), 0, 0, NULL
);
6413 /* Should not happen. If it does, all bets are off. */
6414 if (newnum
!= get_traceframe_number ())
6415 warning (_("could not set remote traceframe"));
6419 remote_fetch_registers (struct target_ops
*ops
,
6420 struct regcache
*regcache
, int regnum
)
6422 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6425 set_remote_traceframe ();
6426 set_general_thread (inferior_ptid
);
6430 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
6432 gdb_assert (reg
!= NULL
);
6434 /* If this register might be in the 'g' packet, try that first -
6435 we are likely to read more than one register. If this is the
6436 first 'g' packet, we might be overly optimistic about its
6437 contents, so fall back to 'p'. */
6438 if (reg
->in_g_packet
)
6440 fetch_registers_using_g (regcache
);
6441 if (reg
->in_g_packet
)
6445 if (fetch_register_using_p (regcache
, reg
))
6448 /* This register is not available. */
6449 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
6454 fetch_registers_using_g (regcache
);
6456 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6457 if (!rsa
->regs
[i
].in_g_packet
)
6458 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
6460 /* This register is not available. */
6461 regcache_raw_supply (regcache
, i
, NULL
);
6465 /* Prepare to store registers. Since we may send them all (using a
6466 'G' request), we have to read out the ones we don't want to change
6470 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
6472 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6474 gdb_byte buf
[MAX_REGISTER_SIZE
];
6476 /* Make sure the entire registers array is valid. */
6477 switch (remote_protocol_packets
[PACKET_P
].support
)
6479 case PACKET_DISABLE
:
6480 case PACKET_SUPPORT_UNKNOWN
:
6481 /* Make sure all the necessary registers are cached. */
6482 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6483 if (rsa
->regs
[i
].in_g_packet
)
6484 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
6491 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
6492 packet was not recognized. */
6495 store_register_using_P (const struct regcache
*regcache
,
6496 struct packet_reg
*reg
)
6498 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
6499 struct remote_state
*rs
= get_remote_state ();
6500 /* Try storing a single register. */
6501 char *buf
= rs
->buf
;
6502 gdb_byte regp
[MAX_REGISTER_SIZE
];
6505 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
6508 if (reg
->pnum
== -1)
6511 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
6512 p
= buf
+ strlen (buf
);
6513 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
6514 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
6516 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6518 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
6523 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
6524 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
6525 case PACKET_UNKNOWN
:
6528 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
6532 /* Store register REGNUM, or all registers if REGNUM == -1, from the
6533 contents of the register cache buffer. FIXME: ignores errors. */
6536 store_registers_using_G (const struct regcache
*regcache
)
6538 struct remote_state
*rs
= get_remote_state ();
6539 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6543 /* Extract all the registers in the regcache copying them into a
6548 regs
= alloca (rsa
->sizeof_g_packet
);
6549 memset (regs
, 0, rsa
->sizeof_g_packet
);
6550 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6552 struct packet_reg
*r
= &rsa
->regs
[i
];
6555 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
6559 /* Command describes registers byte by byte,
6560 each byte encoded as two hex characters. */
6563 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
6565 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
6567 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6568 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
6569 error (_("Could not write registers; remote failure reply '%s'"),
6573 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
6574 of the register cache buffer. FIXME: ignores errors. */
6577 remote_store_registers (struct target_ops
*ops
,
6578 struct regcache
*regcache
, int regnum
)
6580 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6583 set_remote_traceframe ();
6584 set_general_thread (inferior_ptid
);
6588 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
6590 gdb_assert (reg
!= NULL
);
6592 /* Always prefer to store registers using the 'P' packet if
6593 possible; we often change only a small number of registers.
6594 Sometimes we change a larger number; we'd need help from a
6595 higher layer to know to use 'G'. */
6596 if (store_register_using_P (regcache
, reg
))
6599 /* For now, don't complain if we have no way to write the
6600 register. GDB loses track of unavailable registers too
6601 easily. Some day, this may be an error. We don't have
6602 any way to read the register, either... */
6603 if (!reg
->in_g_packet
)
6606 store_registers_using_G (regcache
);
6610 store_registers_using_G (regcache
);
6612 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
6613 if (!rsa
->regs
[i
].in_g_packet
)
6614 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
6615 /* See above for why we do not issue an error here. */
6620 /* Return the number of hex digits in num. */
6623 hexnumlen (ULONGEST num
)
6627 for (i
= 0; num
!= 0; i
++)
6633 /* Set BUF to the minimum number of hex digits representing NUM. */
6636 hexnumstr (char *buf
, ULONGEST num
)
6638 int len
= hexnumlen (num
);
6640 return hexnumnstr (buf
, num
, len
);
6644 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
6647 hexnumnstr (char *buf
, ULONGEST num
, int width
)
6653 for (i
= width
- 1; i
>= 0; i
--)
6655 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
6662 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
6665 remote_address_masked (CORE_ADDR addr
)
6667 unsigned int address_size
= remote_address_size
;
6669 /* If "remoteaddresssize" was not set, default to target address size. */
6671 address_size
= gdbarch_addr_bit (target_gdbarch ());
6673 if (address_size
> 0
6674 && address_size
< (sizeof (ULONGEST
) * 8))
6676 /* Only create a mask when that mask can safely be constructed
6677 in a ULONGEST variable. */
6680 mask
= (mask
<< address_size
) - 1;
6686 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
6687 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
6688 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
6689 (which may be more than *OUT_LEN due to escape characters). The
6690 total number of bytes in the output buffer will be at most
6694 remote_escape_output (const gdb_byte
*buffer
, int len
,
6695 gdb_byte
*out_buf
, int *out_len
,
6698 int input_index
, output_index
;
6701 for (input_index
= 0; input_index
< len
; input_index
++)
6703 gdb_byte b
= buffer
[input_index
];
6705 if (b
== '$' || b
== '#' || b
== '}')
6707 /* These must be escaped. */
6708 if (output_index
+ 2 > out_maxlen
)
6710 out_buf
[output_index
++] = '}';
6711 out_buf
[output_index
++] = b
^ 0x20;
6715 if (output_index
+ 1 > out_maxlen
)
6717 out_buf
[output_index
++] = b
;
6721 *out_len
= input_index
;
6722 return output_index
;
6725 /* Convert BUFFER, escaped data LEN bytes long, into binary data
6726 in OUT_BUF. Return the number of bytes written to OUT_BUF.
6727 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
6729 This function reverses remote_escape_output. It allows more
6730 escaped characters than that function does, in particular because
6731 '*' must be escaped to avoid the run-length encoding processing
6732 in reading packets. */
6735 remote_unescape_input (const gdb_byte
*buffer
, int len
,
6736 gdb_byte
*out_buf
, int out_maxlen
)
6738 int input_index
, output_index
;
6743 for (input_index
= 0; input_index
< len
; input_index
++)
6745 gdb_byte b
= buffer
[input_index
];
6747 if (output_index
+ 1 > out_maxlen
)
6749 warning (_("Received too much data from remote target;"
6750 " ignoring overflow."));
6751 return output_index
;
6756 out_buf
[output_index
++] = b
^ 0x20;
6762 out_buf
[output_index
++] = b
;
6766 error (_("Unmatched escape character in target response."));
6768 return output_index
;
6771 /* Determine whether the remote target supports binary downloading.
6772 This is accomplished by sending a no-op memory write of zero length
6773 to the target at the specified address. It does not suffice to send
6774 the whole packet, since many stubs strip the eighth bit and
6775 subsequently compute a wrong checksum, which causes real havoc with
6778 NOTE: This can still lose if the serial line is not eight-bit
6779 clean. In cases like this, the user should clear "remote
6783 check_binary_download (CORE_ADDR addr
)
6785 struct remote_state
*rs
= get_remote_state ();
6787 switch (remote_protocol_packets
[PACKET_X
].support
)
6789 case PACKET_DISABLE
:
6793 case PACKET_SUPPORT_UNKNOWN
:
6799 p
+= hexnumstr (p
, (ULONGEST
) addr
);
6801 p
+= hexnumstr (p
, (ULONGEST
) 0);
6805 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
6806 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6808 if (rs
->buf
[0] == '\0')
6811 fprintf_unfiltered (gdb_stdlog
,
6812 "binary downloading NOT "
6813 "supported by target\n");
6814 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
6819 fprintf_unfiltered (gdb_stdlog
,
6820 "binary downloading supported by target\n");
6821 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
6828 /* Write memory data directly to the remote machine.
6829 This does not inform the data cache; the data cache uses this.
6830 HEADER is the starting part of the packet.
6831 MEMADDR is the address in the remote memory space.
6832 MYADDR is the address of the buffer in our space.
6833 LEN is the number of bytes.
6834 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
6835 should send data as binary ('X'), or hex-encoded ('M').
6837 The function creates packet of the form
6838 <HEADER><ADDRESS>,<LENGTH>:<DATA>
6840 where encoding of <DATA> is termined by PACKET_FORMAT.
6842 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
6845 Returns the number of bytes transferred, or a negative value (an
6846 'enum target_xfer_error' value) for error. Only transfer a single
6850 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
6851 const gdb_byte
*myaddr
, ssize_t len
,
6852 char packet_format
, int use_length
)
6854 struct remote_state
*rs
= get_remote_state ();
6864 if (packet_format
!= 'X' && packet_format
!= 'M')
6865 internal_error (__FILE__
, __LINE__
,
6866 _("remote_write_bytes_aux: bad packet format"));
6871 payload_size
= get_memory_write_packet_size ();
6873 /* The packet buffer will be large enough for the payload;
6874 get_memory_packet_size ensures this. */
6877 /* Compute the size of the actual payload by subtracting out the
6878 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
6880 payload_size
-= strlen ("$,:#NN");
6882 /* The comma won't be used. */
6884 header_length
= strlen (header
);
6885 payload_size
-= header_length
;
6886 payload_size
-= hexnumlen (memaddr
);
6888 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
6890 strcat (rs
->buf
, header
);
6891 p
= rs
->buf
+ strlen (header
);
6893 /* Compute a best guess of the number of bytes actually transfered. */
6894 if (packet_format
== 'X')
6896 /* Best guess at number of bytes that will fit. */
6897 todo
= min (len
, payload_size
);
6899 payload_size
-= hexnumlen (todo
);
6900 todo
= min (todo
, payload_size
);
6904 /* Num bytes that will fit. */
6905 todo
= min (len
, payload_size
/ 2);
6907 payload_size
-= hexnumlen (todo
);
6908 todo
= min (todo
, payload_size
/ 2);
6912 internal_error (__FILE__
, __LINE__
,
6913 _("minimum packet size too small to write data"));
6915 /* If we already need another packet, then try to align the end
6916 of this packet to a useful boundary. */
6917 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
6918 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
6920 /* Append "<memaddr>". */
6921 memaddr
= remote_address_masked (memaddr
);
6922 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
6929 /* Append <len>. Retain the location/size of <len>. It may need to
6930 be adjusted once the packet body has been created. */
6932 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
6940 /* Append the packet body. */
6941 if (packet_format
== 'X')
6943 /* Binary mode. Send target system values byte by byte, in
6944 increasing byte addresses. Only escape certain critical
6946 payload_length
= remote_escape_output (myaddr
, todo
, (gdb_byte
*) p
,
6947 &nr_bytes
, payload_size
);
6949 /* If not all TODO bytes fit, then we'll need another packet. Make
6950 a second try to keep the end of the packet aligned. Don't do
6951 this if the packet is tiny. */
6952 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
6956 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
6958 if (new_nr_bytes
!= nr_bytes
)
6959 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
6960 (gdb_byte
*) p
, &nr_bytes
,
6964 p
+= payload_length
;
6965 if (use_length
&& nr_bytes
< todo
)
6967 /* Escape chars have filled up the buffer prematurely,
6968 and we have actually sent fewer bytes than planned.
6969 Fix-up the length field of the packet. Use the same
6970 number of characters as before. */
6971 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
6972 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
6977 /* Normal mode: Send target system values byte by byte, in
6978 increasing byte addresses. Each byte is encoded as a two hex
6980 nr_bytes
= bin2hex (myaddr
, p
, todo
);
6984 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
6985 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6987 if (rs
->buf
[0] == 'E')
6988 return TARGET_XFER_E_IO
;
6990 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
6991 fewer bytes than we'd planned. */
6995 /* Write memory data directly to the remote machine.
6996 This does not inform the data cache; the data cache uses this.
6997 MEMADDR is the address in the remote memory space.
6998 MYADDR is the address of the buffer in our space.
6999 LEN is the number of bytes.
7001 Returns number of bytes transferred, or a negative value (an 'enum
7002 target_xfer_error' value) for error. Only transfer a single
7006 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
7008 char *packet_format
= 0;
7010 /* Check whether the target supports binary download. */
7011 check_binary_download (memaddr
);
7013 switch (remote_protocol_packets
[PACKET_X
].support
)
7016 packet_format
= "X";
7018 case PACKET_DISABLE
:
7019 packet_format
= "M";
7021 case PACKET_SUPPORT_UNKNOWN
:
7022 internal_error (__FILE__
, __LINE__
,
7023 _("remote_write_bytes: bad internal state"));
7025 internal_error (__FILE__
, __LINE__
, _("bad switch"));
7028 return remote_write_bytes_aux (packet_format
,
7029 memaddr
, myaddr
, len
, packet_format
[0], 1);
7032 /* Read memory data directly from the remote machine.
7033 This does not use the data cache; the data cache uses this.
7034 MEMADDR is the address in the remote memory space.
7035 MYADDR is the address of the buffer in our space.
7036 LEN is the number of bytes.
7038 Returns number of bytes transferred, or a negative value (an 'enum
7039 target_xfer_error' value) for error. */
7042 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
7044 struct remote_state
*rs
= get_remote_state ();
7045 int max_buf_size
; /* Max size of packet output buffer. */
7053 max_buf_size
= get_memory_read_packet_size ();
7054 /* The packet buffer will be large enough for the payload;
7055 get_memory_packet_size ensures this. */
7057 /* Number if bytes that will fit. */
7058 todo
= min (len
, max_buf_size
/ 2);
7060 /* Construct "m"<memaddr>","<len>". */
7061 memaddr
= remote_address_masked (memaddr
);
7064 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
7066 p
+= hexnumstr (p
, (ULONGEST
) todo
);
7069 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7070 if (rs
->buf
[0] == 'E'
7071 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
7072 && rs
->buf
[3] == '\0')
7073 return TARGET_XFER_E_IO
;
7074 /* Reply describes memory byte by byte, each byte encoded as two hex
7077 i
= hex2bin (p
, myaddr
, todo
);
7078 /* Return what we have. Let higher layers handle partial reads. */
7084 /* Sends a packet with content determined by the printf format string
7085 FORMAT and the remaining arguments, then gets the reply. Returns
7086 whether the packet was a success, a failure, or unknown. */
7088 static enum packet_result
7089 remote_send_printf (const char *format
, ...)
7091 struct remote_state
*rs
= get_remote_state ();
7092 int max_size
= get_remote_packet_size ();
7095 va_start (ap
, format
);
7098 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
7099 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
7101 if (putpkt (rs
->buf
) < 0)
7102 error (_("Communication problem with target."));
7105 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7107 return packet_check_result (rs
->buf
);
7111 restore_remote_timeout (void *p
)
7113 int value
= *(int *)p
;
7115 remote_timeout
= value
;
7118 /* Flash writing can take quite some time. We'll set
7119 effectively infinite timeout for flash operations.
7120 In future, we'll need to decide on a better approach. */
7121 static const int remote_flash_timeout
= 1000;
7124 remote_flash_erase (struct target_ops
*ops
,
7125 ULONGEST address
, LONGEST length
)
7127 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
7128 int saved_remote_timeout
= remote_timeout
;
7129 enum packet_result ret
;
7130 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
7131 &saved_remote_timeout
);
7133 remote_timeout
= remote_flash_timeout
;
7135 ret
= remote_send_printf ("vFlashErase:%s,%s",
7136 phex (address
, addr_size
),
7140 case PACKET_UNKNOWN
:
7141 error (_("Remote target does not support flash erase"));
7143 error (_("Error erasing flash with vFlashErase packet"));
7148 do_cleanups (back_to
);
7152 remote_flash_write (struct target_ops
*ops
,
7153 ULONGEST address
, LONGEST length
,
7154 const gdb_byte
*data
)
7156 int saved_remote_timeout
= remote_timeout
;
7158 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
7159 &saved_remote_timeout
);
7161 remote_timeout
= remote_flash_timeout
;
7162 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
7163 do_cleanups (back_to
);
7169 remote_flash_done (struct target_ops
*ops
)
7171 int saved_remote_timeout
= remote_timeout
;
7173 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
7174 &saved_remote_timeout
);
7176 remote_timeout
= remote_flash_timeout
;
7177 ret
= remote_send_printf ("vFlashDone");
7178 do_cleanups (back_to
);
7182 case PACKET_UNKNOWN
:
7183 error (_("Remote target does not support vFlashDone"));
7185 error (_("Error finishing flash operation"));
7192 remote_files_info (struct target_ops
*ignore
)
7194 puts_filtered ("Debugging a target over a serial line.\n");
7197 /* Stuff for dealing with the packets which are part of this protocol.
7198 See comment at top of file for details. */
7200 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
7201 error to higher layers. Called when a serial error is detected.
7202 The exception message is STRING, followed by a colon and a blank,
7203 the system error message for errno at function entry and final dot
7204 for output compatibility with throw_perror_with_name. */
7207 unpush_and_perror (const char *string
)
7209 int saved_errno
= errno
;
7211 remote_unpush_target ();
7212 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
7213 safe_strerror (saved_errno
));
7216 /* Read a single character from the remote end. */
7219 readchar (int timeout
)
7222 struct remote_state
*rs
= get_remote_state ();
7224 ch
= serial_readchar (rs
->remote_desc
, timeout
);
7229 switch ((enum serial_rc
) ch
)
7232 remote_unpush_target ();
7233 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
7236 unpush_and_perror (_("Remote communication error. "
7237 "Target disconnected."));
7239 case SERIAL_TIMEOUT
:
7245 /* Wrapper for serial_write that closes the target and throws if
7249 remote_serial_write (const char *str
, int len
)
7251 struct remote_state
*rs
= get_remote_state ();
7253 if (serial_write (rs
->remote_desc
, str
, len
))
7255 unpush_and_perror (_("Remote communication error. "
7256 "Target disconnected."));
7260 /* Send the command in *BUF to the remote machine, and read the reply
7261 into *BUF. Report an error if we get an error reply. Resize
7262 *BUF using xrealloc if necessary to hold the result, and update
7266 remote_send (char **buf
,
7270 getpkt (buf
, sizeof_buf
, 0);
7272 if ((*buf
)[0] == 'E')
7273 error (_("Remote failure reply: %s"), *buf
);
7276 /* Return a pointer to an xmalloc'ed string representing an escaped
7277 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t,
7278 etc. The caller is responsible for releasing the returned
7282 escape_buffer (const char *buf
, int n
)
7284 struct cleanup
*old_chain
;
7285 struct ui_file
*stb
;
7288 stb
= mem_fileopen ();
7289 old_chain
= make_cleanup_ui_file_delete (stb
);
7291 fputstrn_unfiltered (buf
, n
, 0, stb
);
7292 str
= ui_file_xstrdup (stb
, NULL
);
7293 do_cleanups (old_chain
);
7297 /* Display a null-terminated packet on stdout, for debugging, using C
7301 print_packet (char *buf
)
7303 puts_filtered ("\"");
7304 fputstr_filtered (buf
, '"', gdb_stdout
);
7305 puts_filtered ("\"");
7311 return putpkt_binary (buf
, strlen (buf
));
7314 /* Send a packet to the remote machine, with error checking. The data
7315 of the packet is in BUF. The string in BUF can be at most
7316 get_remote_packet_size () - 5 to account for the $, # and checksum,
7317 and for a possible /0 if we are debugging (remote_debug) and want
7318 to print the sent packet as a string. */
7321 putpkt_binary (char *buf
, int cnt
)
7323 struct remote_state
*rs
= get_remote_state ();
7325 unsigned char csum
= 0;
7326 char *buf2
= alloca (cnt
+ 6);
7333 /* Catch cases like trying to read memory or listing threads while
7334 we're waiting for a stop reply. The remote server wouldn't be
7335 ready to handle this request, so we'd hang and timeout. We don't
7336 have to worry about this in synchronous mode, because in that
7337 case it's not possible to issue a command while the target is
7338 running. This is not a problem in non-stop mode, because in that
7339 case, the stub is always ready to process serial input. */
7340 if (!non_stop
&& target_can_async_p () && rs
->waiting_for_stop_reply
)
7341 error (_("Cannot execute this command while the target is running."));
7343 /* We're sending out a new packet. Make sure we don't look at a
7344 stale cached response. */
7345 rs
->cached_wait_status
= 0;
7347 /* Copy the packet into buffer BUF2, encapsulating it
7348 and giving it a checksum. */
7353 for (i
= 0; i
< cnt
; i
++)
7359 *p
++ = tohex ((csum
>> 4) & 0xf);
7360 *p
++ = tohex (csum
& 0xf);
7362 /* Send it over and over until we get a positive ack. */
7366 int started_error_output
= 0;
7370 struct cleanup
*old_chain
;
7374 str
= escape_buffer (buf2
, p
- buf2
);
7375 old_chain
= make_cleanup (xfree
, str
);
7376 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s...", str
);
7377 gdb_flush (gdb_stdlog
);
7378 do_cleanups (old_chain
);
7380 remote_serial_write (buf2
, p
- buf2
);
7382 /* If this is a no acks version of the remote protocol, send the
7383 packet and move on. */
7387 /* Read until either a timeout occurs (-2) or '+' is read.
7388 Handle any notification that arrives in the mean time. */
7391 ch
= readchar (remote_timeout
);
7399 case SERIAL_TIMEOUT
:
7402 if (started_error_output
)
7404 putchar_unfiltered ('\n');
7405 started_error_output
= 0;
7414 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
7418 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
7420 case SERIAL_TIMEOUT
:
7424 break; /* Retransmit buffer. */
7428 fprintf_unfiltered (gdb_stdlog
,
7429 "Packet instead of Ack, ignoring it\n");
7430 /* It's probably an old response sent because an ACK
7431 was lost. Gobble up the packet and ack it so it
7432 doesn't get retransmitted when we resend this
7435 remote_serial_write ("+", 1);
7436 continue; /* Now, go look for +. */
7443 /* If we got a notification, handle it, and go back to looking
7445 /* We've found the start of a notification. Now
7446 collect the data. */
7447 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
7452 struct cleanup
*old_chain
;
7455 str
= escape_buffer (rs
->buf
, val
);
7456 old_chain
= make_cleanup (xfree
, str
);
7457 fprintf_unfiltered (gdb_stdlog
,
7458 " Notification received: %s\n",
7460 do_cleanups (old_chain
);
7462 handle_notification (rs
->notif_state
, rs
->buf
);
7463 /* We're in sync now, rewait for the ack. */
7470 if (!started_error_output
)
7472 started_error_output
= 1;
7473 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
7475 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
7476 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
7485 if (!started_error_output
)
7487 started_error_output
= 1;
7488 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
7490 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
7494 break; /* Here to retransmit. */
7498 /* This is wrong. If doing a long backtrace, the user should be
7499 able to get out next time we call QUIT, without anything as
7500 violent as interrupt_query. If we want to provide a way out of
7501 here without getting to the next QUIT, it should be based on
7502 hitting ^C twice as in remote_wait. */
7513 /* Come here after finding the start of a frame when we expected an
7514 ack. Do our best to discard the rest of this packet. */
7523 c
= readchar (remote_timeout
);
7526 case SERIAL_TIMEOUT
:
7527 /* Nothing we can do. */
7530 /* Discard the two bytes of checksum and stop. */
7531 c
= readchar (remote_timeout
);
7533 c
= readchar (remote_timeout
);
7536 case '*': /* Run length encoding. */
7537 /* Discard the repeat count. */
7538 c
= readchar (remote_timeout
);
7543 /* A regular character. */
7549 /* Come here after finding the start of the frame. Collect the rest
7550 into *BUF, verifying the checksum, length, and handling run-length
7551 compression. NUL terminate the buffer. If there is not enough room,
7552 expand *BUF using xrealloc.
7554 Returns -1 on error, number of characters in buffer (ignoring the
7555 trailing NULL) on success. (could be extended to return one of the
7556 SERIAL status indications). */
7559 read_frame (char **buf_p
,
7566 struct remote_state
*rs
= get_remote_state ();
7573 c
= readchar (remote_timeout
);
7576 case SERIAL_TIMEOUT
:
7578 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
7582 fputs_filtered ("Saw new packet start in middle of old one\n",
7584 return -1; /* Start a new packet, count retries. */
7587 unsigned char pktcsum
;
7593 check_0
= readchar (remote_timeout
);
7595 check_1
= readchar (remote_timeout
);
7597 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
7600 fputs_filtered ("Timeout in checksum, retrying\n",
7604 else if (check_0
< 0 || check_1
< 0)
7607 fputs_filtered ("Communication error in checksum\n",
7612 /* Don't recompute the checksum; with no ack packets we
7613 don't have any way to indicate a packet retransmission
7618 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
7619 if (csum
== pktcsum
)
7624 struct cleanup
*old_chain
;
7627 str
= escape_buffer (buf
, bc
);
7628 old_chain
= make_cleanup (xfree
, str
);
7629 fprintf_unfiltered (gdb_stdlog
,
7630 "Bad checksum, sentsum=0x%x, "
7631 "csum=0x%x, buf=%s\n",
7632 pktcsum
, csum
, str
);
7633 do_cleanups (old_chain
);
7635 /* Number of characters in buffer ignoring trailing
7639 case '*': /* Run length encoding. */
7644 c
= readchar (remote_timeout
);
7646 repeat
= c
- ' ' + 3; /* Compute repeat count. */
7648 /* The character before ``*'' is repeated. */
7650 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
7652 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
7654 /* Make some more room in the buffer. */
7655 *sizeof_buf
+= repeat
;
7656 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
7660 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
7666 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
7670 if (bc
>= *sizeof_buf
- 1)
7672 /* Make some more room in the buffer. */
7674 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
7685 /* Read a packet from the remote machine, with error checking, and
7686 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
7687 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
7688 rather than timing out; this is used (in synchronous mode) to wait
7689 for a target that is is executing user code to stop. */
7690 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
7691 don't have to change all the calls to getpkt to deal with the
7692 return value, because at the moment I don't know what the right
7693 thing to do it for those. */
7701 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
7705 /* Read a packet from the remote machine, with error checking, and
7706 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
7707 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
7708 rather than timing out; this is used (in synchronous mode) to wait
7709 for a target that is is executing user code to stop. If FOREVER ==
7710 0, this function is allowed to time out gracefully and return an
7711 indication of this to the caller. Otherwise return the number of
7712 bytes read. If EXPECTING_NOTIF, consider receiving a notification
7713 enough reason to return to the caller. *IS_NOTIF is an output
7714 boolean that indicates whether *BUF holds a notification or not
7715 (a regular packet). */
7718 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
7719 int expecting_notif
, int *is_notif
)
7721 struct remote_state
*rs
= get_remote_state ();
7727 /* We're reading a new response. Make sure we don't look at a
7728 previously cached response. */
7729 rs
->cached_wait_status
= 0;
7731 strcpy (*buf
, "timeout");
7734 timeout
= watchdog
> 0 ? watchdog
: -1;
7735 else if (expecting_notif
)
7736 timeout
= 0; /* There should already be a char in the buffer. If
7739 timeout
= remote_timeout
;
7743 /* Process any number of notifications, and then return when
7747 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
7749 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
7751 /* This can loop forever if the remote side sends us
7752 characters continuously, but if it pauses, we'll get
7753 SERIAL_TIMEOUT from readchar because of timeout. Then
7754 we'll count that as a retry.
7756 Note that even when forever is set, we will only wait
7757 forever prior to the start of a packet. After that, we
7758 expect characters to arrive at a brisk pace. They should
7759 show up within remote_timeout intervals. */
7761 c
= readchar (timeout
);
7762 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
7764 if (c
== SERIAL_TIMEOUT
)
7766 if (expecting_notif
)
7767 return -1; /* Don't complain, it's normal to not get
7768 anything in this case. */
7770 if (forever
) /* Watchdog went off? Kill the target. */
7773 remote_unpush_target ();
7774 throw_error (TARGET_CLOSE_ERROR
,
7775 _("Watchdog timeout has expired. "
7776 "Target detached."));
7779 fputs_filtered ("Timed out.\n", gdb_stdlog
);
7783 /* We've found the start of a packet or notification.
7784 Now collect the data. */
7785 val
= read_frame (buf
, sizeof_buf
);
7790 remote_serial_write ("-", 1);
7793 if (tries
> MAX_TRIES
)
7795 /* We have tried hard enough, and just can't receive the
7796 packet/notification. Give up. */
7797 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
7799 /* Skip the ack char if we're in no-ack mode. */
7800 if (!rs
->noack_mode
)
7801 remote_serial_write ("+", 1);
7805 /* If we got an ordinary packet, return that to our caller. */
7810 struct cleanup
*old_chain
;
7813 str
= escape_buffer (*buf
, val
);
7814 old_chain
= make_cleanup (xfree
, str
);
7815 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s\n", str
);
7816 do_cleanups (old_chain
);
7819 /* Skip the ack char if we're in no-ack mode. */
7820 if (!rs
->noack_mode
)
7821 remote_serial_write ("+", 1);
7822 if (is_notif
!= NULL
)
7827 /* If we got a notification, handle it, and go back to looking
7831 gdb_assert (c
== '%');
7835 struct cleanup
*old_chain
;
7838 str
= escape_buffer (*buf
, val
);
7839 old_chain
= make_cleanup (xfree
, str
);
7840 fprintf_unfiltered (gdb_stdlog
,
7841 " Notification received: %s\n",
7843 do_cleanups (old_chain
);
7845 if (is_notif
!= NULL
)
7848 handle_notification (rs
->notif_state
, *buf
);
7850 /* Notifications require no acknowledgement. */
7852 if (expecting_notif
)
7859 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
7861 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
7865 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
7868 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
7874 remote_kill (struct target_ops
*ops
)
7876 struct gdb_exception ex
;
7878 /* Catch errors so the user can quit from gdb even when we
7879 aren't on speaking terms with the remote system. */
7880 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
7886 if (ex
.error
== TARGET_CLOSE_ERROR
)
7888 /* If we got an (EOF) error that caused the target
7889 to go away, then we're done, that's what we wanted.
7890 "k" is susceptible to cause a premature EOF, given
7891 that the remote server isn't actually required to
7892 reply to "k", and it can happen that it doesn't
7893 even get to reply ACK to the "k". */
7897 /* Otherwise, something went wrong. We didn't actually kill
7898 the target. Just propagate the exception, and let the
7899 user or higher layers decide what to do. */
7900 throw_exception (ex
);
7903 /* We've killed the remote end, we get to mourn it. Since this is
7904 target remote, single-process, mourning the inferior also
7905 unpushes remote_ops. */
7906 target_mourn_inferior ();
7910 remote_vkill (int pid
, struct remote_state
*rs
)
7912 if (remote_protocol_packets
[PACKET_vKill
].support
== PACKET_DISABLE
)
7915 /* Tell the remote target to detach. */
7916 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
7918 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7920 if (packet_ok (rs
->buf
,
7921 &remote_protocol_packets
[PACKET_vKill
]) == PACKET_OK
)
7923 else if (remote_protocol_packets
[PACKET_vKill
].support
== PACKET_DISABLE
)
7930 extended_remote_kill (struct target_ops
*ops
)
7933 int pid
= ptid_get_pid (inferior_ptid
);
7934 struct remote_state
*rs
= get_remote_state ();
7936 res
= remote_vkill (pid
, rs
);
7937 if (res
== -1 && !(rs
->extended
&& remote_multi_process_p (rs
)))
7939 /* Don't try 'k' on a multi-process aware stub -- it has no way
7940 to specify the pid. */
7944 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7945 if (rs
->buf
[0] != 'O' || rs
->buf
[0] != 'K')
7948 /* Don't wait for it to die. I'm not really sure it matters whether
7949 we do or not. For the existing stubs, kill is a noop. */
7955 error (_("Can't kill process"));
7957 target_mourn_inferior ();
7961 remote_mourn (struct target_ops
*ops
)
7963 remote_mourn_1 (ops
);
7966 /* Worker function for remote_mourn. */
7968 remote_mourn_1 (struct target_ops
*target
)
7970 unpush_target (target
);
7972 /* remote_close takes care of doing most of the clean up. */
7973 generic_mourn_inferior ();
7977 extended_remote_mourn_1 (struct target_ops
*target
)
7979 struct remote_state
*rs
= get_remote_state ();
7981 /* In case we got here due to an error, but we're going to stay
7983 rs
->waiting_for_stop_reply
= 0;
7985 /* If the current general thread belonged to the process we just
7986 detached from or has exited, the remote side current general
7987 thread becomes undefined. Considering a case like this:
7989 - We just got here due to a detach.
7990 - The process that we're detaching from happens to immediately
7991 report a global breakpoint being hit in non-stop mode, in the
7992 same thread we had selected before.
7993 - GDB attaches to this process again.
7994 - This event happens to be the next event we handle.
7996 GDB would consider that the current general thread didn't need to
7997 be set on the stub side (with Hg), since for all it knew,
7998 GENERAL_THREAD hadn't changed.
8000 Notice that although in all-stop mode, the remote server always
8001 sets the current thread to the thread reporting the stop event,
8002 that doesn't happen in non-stop mode; in non-stop, the stub *must
8003 not* change the current thread when reporting a breakpoint hit,
8004 due to the decoupling of event reporting and event handling.
8006 To keep things simple, we always invalidate our notion of the
8008 record_currthread (rs
, minus_one_ptid
);
8010 /* Unlike "target remote", we do not want to unpush the target; then
8011 the next time the user says "run", we won't be connected. */
8013 /* Call common code to mark the inferior as not running. */
8014 generic_mourn_inferior ();
8016 if (!have_inferiors ())
8018 if (!remote_multi_process_p (rs
))
8020 /* Check whether the target is running now - some remote stubs
8021 automatically restart after kill. */
8023 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8025 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
8027 /* Assume that the target has been restarted. Set
8028 inferior_ptid so that bits of core GDB realizes
8029 there's something here, e.g., so that the user can
8030 say "kill" again. */
8031 inferior_ptid
= magic_null_ptid
;
8038 extended_remote_mourn (struct target_ops
*ops
)
8040 extended_remote_mourn_1 (ops
);
8044 extended_remote_supports_disable_randomization (void)
8046 return (remote_protocol_packets
[PACKET_QDisableRandomization
].support
8051 extended_remote_disable_randomization (int val
)
8053 struct remote_state
*rs
= get_remote_state ();
8056 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
8059 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
8061 error (_("Target does not support QDisableRandomization."));
8062 if (strcmp (reply
, "OK") != 0)
8063 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
8067 extended_remote_run (char *args
)
8069 struct remote_state
*rs
= get_remote_state ();
8072 /* If the user has disabled vRun support, or we have detected that
8073 support is not available, do not try it. */
8074 if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
8077 strcpy (rs
->buf
, "vRun;");
8078 len
= strlen (rs
->buf
);
8080 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
8081 error (_("Remote file name too long for run packet"));
8082 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
, 0);
8084 gdb_assert (args
!= NULL
);
8087 struct cleanup
*back_to
;
8091 argv
= gdb_buildargv (args
);
8092 back_to
= make_cleanup ((void (*) (void *)) freeargv
, argv
);
8093 for (i
= 0; argv
[i
] != NULL
; i
++)
8095 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
8096 error (_("Argument list too long for run packet"));
8097 rs
->buf
[len
++] = ';';
8098 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
, 0);
8100 do_cleanups (back_to
);
8103 rs
->buf
[len
++] = '\0';
8106 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8108 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]) == PACKET_OK
)
8110 /* We have a wait response. All is well. */
8113 else if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
8114 /* It wasn't disabled before, but it is now. */
8118 if (remote_exec_file
[0] == '\0')
8119 error (_("Running the default executable on the remote target failed; "
8120 "try \"set remote exec-file\"?"));
8122 error (_("Running \"%s\" on the remote target failed"),
8127 /* In the extended protocol we want to be able to do things like
8128 "run" and have them basically work as expected. So we need
8129 a special create_inferior function. We support changing the
8130 executable file and the command line arguments, but not the
8134 extended_remote_create_inferior_1 (char *exec_file
, char *args
,
8135 char **env
, int from_tty
)
8139 struct remote_state
*rs
= get_remote_state ();
8141 /* If running asynchronously, register the target file descriptor
8142 with the event loop. */
8143 if (target_can_async_p ())
8144 target_async (inferior_event_handler
, 0);
8146 /* Disable address space randomization if requested (and supported). */
8147 if (extended_remote_supports_disable_randomization ())
8148 extended_remote_disable_randomization (disable_randomization
);
8150 /* Now restart the remote server. */
8151 run_worked
= extended_remote_run (args
) != -1;
8154 /* vRun was not supported. Fail if we need it to do what the
8156 if (remote_exec_file
[0])
8157 error (_("Remote target does not support \"set remote exec-file\""));
8159 error (_("Remote target does not support \"set args\" or run <ARGS>"));
8161 /* Fall back to "R". */
8162 extended_remote_restart ();
8165 if (!have_inferiors ())
8167 /* Clean up from the last time we ran, before we mark the target
8168 running again. This will mark breakpoints uninserted, and
8169 get_offsets may insert breakpoints. */
8170 init_thread_list ();
8171 init_wait_for_inferior ();
8174 /* vRun's success return is a stop reply. */
8175 stop_reply
= run_worked
? rs
->buf
: NULL
;
8176 add_current_inferior_and_thread (stop_reply
);
8178 /* Get updated offsets, if the stub uses qOffsets. */
8183 extended_remote_create_inferior (struct target_ops
*ops
,
8184 char *exec_file
, char *args
,
8185 char **env
, int from_tty
)
8187 extended_remote_create_inferior_1 (exec_file
, args
, env
, from_tty
);
8191 /* Given a location's target info BP_TGT and the packet buffer BUF, output
8192 the list of conditions (in agent expression bytecode format), if any, the
8193 target needs to evaluate. The output is placed into the packet buffer
8194 started from BUF and ended at BUF_END. */
8197 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
8198 struct bp_target_info
*bp_tgt
, char *buf
,
8201 struct agent_expr
*aexpr
= NULL
;
8204 char *buf_start
= buf
;
8206 if (VEC_empty (agent_expr_p
, bp_tgt
->conditions
))
8209 buf
+= strlen (buf
);
8210 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
8213 /* Send conditions to the target and free the vector. */
8215 VEC_iterate (agent_expr_p
, bp_tgt
->conditions
, ix
, aexpr
);
8218 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
8219 buf
+= strlen (buf
);
8220 for (i
= 0; i
< aexpr
->len
; ++i
)
8221 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
8228 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
8229 struct bp_target_info
*bp_tgt
, char *buf
)
8231 struct agent_expr
*aexpr
= NULL
;
8234 if (VEC_empty (agent_expr_p
, bp_tgt
->tcommands
))
8237 buf
+= strlen (buf
);
8239 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
8240 buf
+= strlen (buf
);
8242 /* Concatenate all the agent expressions that are commands into the
8245 VEC_iterate (agent_expr_p
, bp_tgt
->tcommands
, ix
, aexpr
);
8248 sprintf (buf
, "X%x,", aexpr
->len
);
8249 buf
+= strlen (buf
);
8250 for (i
= 0; i
< aexpr
->len
; ++i
)
8251 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
8256 /* Insert a breakpoint. On targets that have software breakpoint
8257 support, we ask the remote target to do the work; on targets
8258 which don't, we insert a traditional memory breakpoint. */
8261 remote_insert_breakpoint (struct target_ops
*ops
,
8262 struct gdbarch
*gdbarch
,
8263 struct bp_target_info
*bp_tgt
)
8265 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
8266 If it succeeds, then set the support to PACKET_ENABLE. If it
8267 fails, and the user has explicitly requested the Z support then
8268 report an error, otherwise, mark it disabled and go on. */
8270 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
8272 CORE_ADDR addr
= bp_tgt
->placed_address
;
8273 struct remote_state
*rs
;
8276 struct condition_list
*cond
= NULL
;
8278 /* Make sure the remote is pointing at the right process, if
8280 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8281 set_general_process ();
8283 gdbarch_remote_breakpoint_from_pc (gdbarch
, &addr
, &bpsize
);
8285 rs
= get_remote_state ();
8287 endbuf
= rs
->buf
+ get_remote_packet_size ();
8292 addr
= (ULONGEST
) remote_address_masked (addr
);
8293 p
+= hexnumstr (p
, addr
);
8294 xsnprintf (p
, endbuf
- p
, ",%d", bpsize
);
8296 if (remote_supports_cond_breakpoints ())
8297 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
8299 if (remote_can_run_breakpoint_commands ())
8300 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
8303 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8305 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
8310 bp_tgt
->placed_address
= addr
;
8311 bp_tgt
->placed_size
= bpsize
;
8313 case PACKET_UNKNOWN
:
8318 /* If this breakpoint has target-side commands but this stub doesn't
8319 support Z0 packets, throw error. */
8320 if (!VEC_empty (agent_expr_p
, bp_tgt
->tcommands
))
8321 throw_error (NOT_SUPPORTED_ERROR
, _("\
8322 Target doesn't support breakpoints that have target side commands."));
8324 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
8328 remote_remove_breakpoint (struct target_ops
*ops
,
8329 struct gdbarch
*gdbarch
,
8330 struct bp_target_info
*bp_tgt
)
8332 CORE_ADDR addr
= bp_tgt
->placed_address
;
8333 struct remote_state
*rs
= get_remote_state ();
8335 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
8338 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8340 /* Make sure the remote is pointing at the right process, if
8342 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8343 set_general_process ();
8349 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
8350 p
+= hexnumstr (p
, addr
);
8351 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->placed_size
);
8354 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8356 return (rs
->buf
[0] == 'E');
8359 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
8363 watchpoint_to_Z_packet (int type
)
8368 return Z_PACKET_WRITE_WP
;
8371 return Z_PACKET_READ_WP
;
8374 return Z_PACKET_ACCESS_WP
;
8377 internal_error (__FILE__
, __LINE__
,
8378 _("hw_bp_to_z: bad watchpoint type %d"), type
);
8383 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
8384 struct expression
*cond
)
8386 struct remote_state
*rs
= get_remote_state ();
8387 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8389 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
8391 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
8394 /* Make sure the remote is pointing at the right process, if
8396 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8397 set_general_process ();
8399 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
8400 p
= strchr (rs
->buf
, '\0');
8401 addr
= remote_address_masked (addr
);
8402 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8403 xsnprintf (p
, endbuf
- p
, ",%x", len
);
8406 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8408 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
8412 case PACKET_UNKNOWN
:
8417 internal_error (__FILE__
, __LINE__
,
8418 _("remote_insert_watchpoint: reached end of function"));
8422 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
8423 CORE_ADDR start
, int length
)
8425 CORE_ADDR diff
= remote_address_masked (addr
- start
);
8427 return diff
< length
;
8432 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
8433 struct expression
*cond
)
8435 struct remote_state
*rs
= get_remote_state ();
8436 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8438 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
8440 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
8443 /* Make sure the remote is pointing at the right process, if
8445 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8446 set_general_process ();
8448 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
8449 p
= strchr (rs
->buf
, '\0');
8450 addr
= remote_address_masked (addr
);
8451 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8452 xsnprintf (p
, endbuf
- p
, ",%x", len
);
8454 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8456 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
8459 case PACKET_UNKNOWN
:
8464 internal_error (__FILE__
, __LINE__
,
8465 _("remote_remove_watchpoint: reached end of function"));
8469 int remote_hw_watchpoint_limit
= -1;
8470 int remote_hw_watchpoint_length_limit
= -1;
8471 int remote_hw_breakpoint_limit
= -1;
8474 remote_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
8476 if (remote_hw_watchpoint_length_limit
== 0)
8478 else if (remote_hw_watchpoint_length_limit
< 0)
8480 else if (len
<= remote_hw_watchpoint_length_limit
)
8487 remote_check_watch_resources (int type
, int cnt
, int ot
)
8489 if (type
== bp_hardware_breakpoint
)
8491 if (remote_hw_breakpoint_limit
== 0)
8493 else if (remote_hw_breakpoint_limit
< 0)
8495 else if (cnt
<= remote_hw_breakpoint_limit
)
8500 if (remote_hw_watchpoint_limit
== 0)
8502 else if (remote_hw_watchpoint_limit
< 0)
8506 else if (cnt
<= remote_hw_watchpoint_limit
)
8513 remote_stopped_by_watchpoint (void)
8515 struct remote_state
*rs
= get_remote_state ();
8517 return rs
->remote_stopped_by_watchpoint_p
;
8521 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
8523 struct remote_state
*rs
= get_remote_state ();
8526 if (remote_stopped_by_watchpoint ())
8528 *addr_p
= rs
->remote_watch_data_address
;
8537 remote_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
8538 struct bp_target_info
*bp_tgt
)
8541 struct remote_state
*rs
;
8545 /* The length field should be set to the size of a breakpoint
8546 instruction, even though we aren't inserting one ourselves. */
8548 gdbarch_remote_breakpoint_from_pc
8549 (gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
8551 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
8554 /* Make sure the remote is pointing at the right process, if
8556 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8557 set_general_process ();
8559 rs
= get_remote_state ();
8561 endbuf
= rs
->buf
+ get_remote_packet_size ();
8567 addr
= remote_address_masked (bp_tgt
->placed_address
);
8568 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8569 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->placed_size
);
8571 if (remote_supports_cond_breakpoints ())
8572 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
8574 if (remote_can_run_breakpoint_commands ())
8575 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
8578 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8580 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
8583 if (rs
->buf
[1] == '.')
8585 message
= strchr (rs
->buf
+ 2, '.');
8587 error (_("Remote failure reply: %s"), message
+ 1);
8590 case PACKET_UNKNOWN
:
8595 internal_error (__FILE__
, __LINE__
,
8596 _("remote_insert_hw_breakpoint: reached end of function"));
8601 remote_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
8602 struct bp_target_info
*bp_tgt
)
8605 struct remote_state
*rs
= get_remote_state ();
8607 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8609 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
8612 /* Make sure the remote is pointing at the right process, if
8614 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8615 set_general_process ();
8621 addr
= remote_address_masked (bp_tgt
->placed_address
);
8622 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8623 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->placed_size
);
8626 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8628 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
8631 case PACKET_UNKNOWN
:
8636 internal_error (__FILE__
, __LINE__
,
8637 _("remote_remove_hw_breakpoint: reached end of function"));
8640 /* Verify memory using the "qCRC:" request. */
8643 remote_verify_memory (struct target_ops
*ops
,
8644 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
8646 struct remote_state
*rs
= get_remote_state ();
8647 unsigned long host_crc
, target_crc
;
8650 /* Make sure the remote is pointing at the right process. */
8651 set_general_process ();
8653 /* FIXME: assumes lma can fit into long. */
8654 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
8655 (long) lma
, (long) size
);
8658 /* Be clever; compute the host_crc before waiting for target
8660 host_crc
= xcrc32 (data
, size
, 0xffffffff);
8662 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8663 if (rs
->buf
[0] == 'E')
8666 if (rs
->buf
[0] != 'C')
8667 error (_("remote target does not support this operation"));
8669 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
8670 target_crc
= target_crc
* 16 + fromhex (*tmp
);
8672 return (host_crc
== target_crc
);
8675 /* compare-sections command
8677 With no arguments, compares each loadable section in the exec bfd
8678 with the same memory range on the target, and reports mismatches.
8679 Useful for verifying the image on the target against the exec file. */
8682 compare_sections_command (char *args
, int from_tty
)
8685 struct cleanup
*old_chain
;
8687 const char *sectname
;
8695 error (_("command cannot be used without an exec file"));
8697 /* Make sure the remote is pointing at the right process. */
8698 set_general_process ();
8700 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
8702 if (!(s
->flags
& SEC_LOAD
))
8703 continue; /* Skip non-loadable section. */
8705 size
= bfd_get_section_size (s
);
8707 continue; /* Skip zero-length section. */
8709 sectname
= bfd_get_section_name (exec_bfd
, s
);
8710 if (args
&& strcmp (args
, sectname
) != 0)
8711 continue; /* Not the section selected by user. */
8713 matched
= 1; /* Do this section. */
8716 sectdata
= xmalloc (size
);
8717 old_chain
= make_cleanup (xfree
, sectdata
);
8718 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
8720 res
= target_verify_memory (sectdata
, lma
, size
);
8723 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
8724 paddress (target_gdbarch (), lma
),
8725 paddress (target_gdbarch (), lma
+ size
));
8727 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
8728 paddress (target_gdbarch (), lma
),
8729 paddress (target_gdbarch (), lma
+ size
));
8731 printf_filtered ("matched.\n");
8734 printf_filtered ("MIS-MATCHED!\n");
8738 do_cleanups (old_chain
);
8741 warning (_("One or more sections of the remote executable does not match\n\
8742 the loaded file\n"));
8743 if (args
&& !matched
)
8744 printf_filtered (_("No loaded section named '%s'.\n"), args
);
8747 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
8748 into remote target. The number of bytes written to the remote
8749 target is returned, or -1 for error. */
8752 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
8753 const char *annex
, const gdb_byte
*writebuf
,
8754 ULONGEST offset
, LONGEST len
,
8755 struct packet_config
*packet
)
8759 struct remote_state
*rs
= get_remote_state ();
8760 int max_size
= get_memory_write_packet_size ();
8762 if (packet
->support
== PACKET_DISABLE
)
8765 /* Insert header. */
8766 i
= snprintf (rs
->buf
, max_size
,
8767 "qXfer:%s:write:%s:%s:",
8768 object_name
, annex
? annex
: "",
8769 phex_nz (offset
, sizeof offset
));
8770 max_size
-= (i
+ 1);
8772 /* Escape as much data as fits into rs->buf. */
8773 buf_len
= remote_escape_output
8774 (writebuf
, len
, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
8776 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
8777 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
8778 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
8781 unpack_varlen_hex (rs
->buf
, &n
);
8785 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
8786 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
8787 number of bytes read is returned, or 0 for EOF, or -1 for error.
8788 The number of bytes read may be less than LEN without indicating an
8789 EOF. PACKET is checked and updated to indicate whether the remote
8790 target supports this object. */
8793 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
8795 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
8796 struct packet_config
*packet
)
8798 struct remote_state
*rs
= get_remote_state ();
8799 LONGEST i
, n
, packet_len
;
8801 if (packet
->support
== PACKET_DISABLE
)
8804 /* Check whether we've cached an end-of-object packet that matches
8806 if (rs
->finished_object
)
8808 if (strcmp (object_name
, rs
->finished_object
) == 0
8809 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
8810 && offset
== rs
->finished_offset
)
8813 /* Otherwise, we're now reading something different. Discard
8815 xfree (rs
->finished_object
);
8816 xfree (rs
->finished_annex
);
8817 rs
->finished_object
= NULL
;
8818 rs
->finished_annex
= NULL
;
8821 /* Request only enough to fit in a single packet. The actual data
8822 may not, since we don't know how much of it will need to be escaped;
8823 the target is free to respond with slightly less data. We subtract
8824 five to account for the response type and the protocol frame. */
8825 n
= min (get_remote_packet_size () - 5, len
);
8826 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
8827 object_name
, annex
? annex
: "",
8828 phex_nz (offset
, sizeof offset
),
8829 phex_nz (n
, sizeof n
));
8830 i
= putpkt (rs
->buf
);
8835 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
8836 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
8839 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
8840 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
8842 /* 'm' means there is (or at least might be) more data after this
8843 batch. That does not make sense unless there's at least one byte
8844 of data in this reply. */
8845 if (rs
->buf
[0] == 'm' && packet_len
== 1)
8846 error (_("Remote qXfer reply contained no data."));
8848 /* Got some data. */
8849 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
8850 packet_len
- 1, readbuf
, n
);
8852 /* 'l' is an EOF marker, possibly including a final block of data,
8853 or possibly empty. If we have the final block of a non-empty
8854 object, record this fact to bypass a subsequent partial read. */
8855 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
8857 rs
->finished_object
= xstrdup (object_name
);
8858 rs
->finished_annex
= xstrdup (annex
? annex
: "");
8859 rs
->finished_offset
= offset
+ i
;
8866 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
8867 const char *annex
, gdb_byte
*readbuf
,
8868 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
8870 struct remote_state
*rs
;
8875 set_remote_traceframe ();
8876 set_general_thread (inferior_ptid
);
8878 rs
= get_remote_state ();
8880 /* Handle memory using the standard memory routines. */
8881 if (object
== TARGET_OBJECT_MEMORY
)
8885 /* If the remote target is connected but not running, we should
8886 pass this request down to a lower stratum (e.g. the executable
8888 if (!target_has_execution
)
8891 if (writebuf
!= NULL
)
8892 xfered
= remote_write_bytes (offset
, writebuf
, len
);
8894 xfered
= remote_read_bytes (offset
, readbuf
, len
);
8899 /* Handle SPU memory using qxfer packets. */
8900 if (object
== TARGET_OBJECT_SPU
)
8903 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
8904 &remote_protocol_packets
8905 [PACKET_qXfer_spu_read
]);
8907 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
8908 &remote_protocol_packets
8909 [PACKET_qXfer_spu_write
]);
8912 /* Handle extra signal info using qxfer packets. */
8913 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
8916 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
8917 &remote_protocol_packets
8918 [PACKET_qXfer_siginfo_read
]);
8920 return remote_write_qxfer (ops
, "siginfo", annex
,
8921 writebuf
, offset
, len
,
8922 &remote_protocol_packets
8923 [PACKET_qXfer_siginfo_write
]);
8926 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
8929 return remote_read_qxfer (ops
, "statictrace", annex
,
8930 readbuf
, offset
, len
,
8931 &remote_protocol_packets
8932 [PACKET_qXfer_statictrace_read
]);
8937 /* Only handle flash writes. */
8938 if (writebuf
!= NULL
)
8944 case TARGET_OBJECT_FLASH
:
8945 return remote_flash_write (ops
, offset
, len
, writebuf
);
8952 /* Map pre-existing objects onto letters. DO NOT do this for new
8953 objects!!! Instead specify new query packets. */
8956 case TARGET_OBJECT_AVR
:
8960 case TARGET_OBJECT_AUXV
:
8961 gdb_assert (annex
== NULL
);
8962 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
8963 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
8965 case TARGET_OBJECT_AVAILABLE_FEATURES
:
8966 return remote_read_qxfer
8967 (ops
, "features", annex
, readbuf
, offset
, len
,
8968 &remote_protocol_packets
[PACKET_qXfer_features
]);
8970 case TARGET_OBJECT_LIBRARIES
:
8971 return remote_read_qxfer
8972 (ops
, "libraries", annex
, readbuf
, offset
, len
,
8973 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
8975 case TARGET_OBJECT_LIBRARIES_SVR4
:
8976 return remote_read_qxfer
8977 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
,
8978 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
8980 case TARGET_OBJECT_MEMORY_MAP
:
8981 gdb_assert (annex
== NULL
);
8982 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
8983 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
8985 case TARGET_OBJECT_OSDATA
:
8986 /* Should only get here if we're connected. */
8987 gdb_assert (rs
->remote_desc
);
8988 return remote_read_qxfer
8989 (ops
, "osdata", annex
, readbuf
, offset
, len
,
8990 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
8992 case TARGET_OBJECT_THREADS
:
8993 gdb_assert (annex
== NULL
);
8994 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
8995 &remote_protocol_packets
[PACKET_qXfer_threads
]);
8997 case TARGET_OBJECT_TRACEFRAME_INFO
:
8998 gdb_assert (annex
== NULL
);
8999 return remote_read_qxfer
9000 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
,
9001 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
9003 case TARGET_OBJECT_FDPIC
:
9004 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
9005 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
9007 case TARGET_OBJECT_OPENVMS_UIB
:
9008 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
9009 &remote_protocol_packets
[PACKET_qXfer_uib
]);
9011 case TARGET_OBJECT_BTRACE
:
9012 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
9013 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
9019 /* Note: a zero OFFSET and LEN can be used to query the minimum
9021 if (offset
== 0 && len
== 0)
9022 return (get_remote_packet_size ());
9023 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
9024 large enough let the caller deal with it. */
9025 if (len
< get_remote_packet_size ())
9027 len
= get_remote_packet_size ();
9029 /* Except for querying the minimum buffer size, target must be open. */
9030 if (!rs
->remote_desc
)
9031 error (_("remote query is only available after target open"));
9033 gdb_assert (annex
!= NULL
);
9034 gdb_assert (readbuf
!= NULL
);
9040 /* We used one buffer char for the remote protocol q command and
9041 another for the query type. As the remote protocol encapsulation
9042 uses 4 chars plus one extra in case we are debugging
9043 (remote_debug), we have PBUFZIZ - 7 left to pack the query
9046 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
9048 /* Bad caller may have sent forbidden characters. */
9049 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
9054 gdb_assert (annex
[i
] == '\0');
9056 i
= putpkt (rs
->buf
);
9060 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9061 strcpy ((char *) readbuf
, rs
->buf
);
9063 return strlen ((char *) readbuf
);
9067 remote_search_memory (struct target_ops
* ops
,
9068 CORE_ADDR start_addr
, ULONGEST search_space_len
,
9069 const gdb_byte
*pattern
, ULONGEST pattern_len
,
9070 CORE_ADDR
*found_addrp
)
9072 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9073 struct remote_state
*rs
= get_remote_state ();
9074 int max_size
= get_memory_write_packet_size ();
9075 struct packet_config
*packet
=
9076 &remote_protocol_packets
[PACKET_qSearch_memory
];
9077 /* Number of packet bytes used to encode the pattern;
9078 this could be more than PATTERN_LEN due to escape characters. */
9079 int escaped_pattern_len
;
9080 /* Amount of pattern that was encodable in the packet. */
9081 int used_pattern_len
;
9084 ULONGEST found_addr
;
9086 /* Don't go to the target if we don't have to.
9087 This is done before checking packet->support to avoid the possibility that
9088 a success for this edge case means the facility works in general. */
9089 if (pattern_len
> search_space_len
)
9091 if (pattern_len
== 0)
9093 *found_addrp
= start_addr
;
9097 /* If we already know the packet isn't supported, fall back to the simple
9098 way of searching memory. */
9100 if (packet
->support
== PACKET_DISABLE
)
9102 /* Target doesn't provided special support, fall back and use the
9103 standard support (copy memory and do the search here). */
9104 return simple_search_memory (ops
, start_addr
, search_space_len
,
9105 pattern
, pattern_len
, found_addrp
);
9108 /* Make sure the remote is pointing at the right process. */
9109 set_general_process ();
9111 /* Insert header. */
9112 i
= snprintf (rs
->buf
, max_size
,
9113 "qSearch:memory:%s;%s;",
9114 phex_nz (start_addr
, addr_size
),
9115 phex_nz (search_space_len
, sizeof (search_space_len
)));
9116 max_size
-= (i
+ 1);
9118 /* Escape as much data as fits into rs->buf. */
9119 escaped_pattern_len
=
9120 remote_escape_output (pattern
, pattern_len
, (gdb_byte
*) rs
->buf
+ i
,
9121 &used_pattern_len
, max_size
);
9123 /* Bail if the pattern is too large. */
9124 if (used_pattern_len
!= pattern_len
)
9125 error (_("Pattern is too large to transmit to remote target."));
9127 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
9128 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
9129 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
9131 /* The request may not have worked because the command is not
9132 supported. If so, fall back to the simple way. */
9133 if (packet
->support
== PACKET_DISABLE
)
9135 return simple_search_memory (ops
, start_addr
, search_space_len
,
9136 pattern
, pattern_len
, found_addrp
);
9141 if (rs
->buf
[0] == '0')
9143 else if (rs
->buf
[0] == '1')
9146 if (rs
->buf
[1] != ',')
9147 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
9148 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
9149 *found_addrp
= found_addr
;
9152 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
9158 remote_rcmd (char *command
,
9159 struct ui_file
*outbuf
)
9161 struct remote_state
*rs
= get_remote_state ();
9164 if (!rs
->remote_desc
)
9165 error (_("remote rcmd is only available after target open"));
9167 /* Send a NULL command across as an empty command. */
9168 if (command
== NULL
)
9171 /* The query prefix. */
9172 strcpy (rs
->buf
, "qRcmd,");
9173 p
= strchr (rs
->buf
, '\0');
9175 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
9176 > get_remote_packet_size ())
9177 error (_("\"monitor\" command ``%s'' is too long."), command
);
9179 /* Encode the actual command. */
9180 bin2hex ((gdb_byte
*) command
, p
, 0);
9182 if (putpkt (rs
->buf
) < 0)
9183 error (_("Communication problem with target."));
9185 /* get/display the response */
9190 /* XXX - see also remote_get_noisy_reply(). */
9191 QUIT
; /* Allow user to bail out with ^C. */
9193 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
9195 /* Timeout. Continue to (try to) read responses.
9196 This is better than stopping with an error, assuming the stub
9197 is still executing the (long) monitor command.
9198 If needed, the user can interrupt gdb using C-c, obtaining
9199 an effect similar to stop on timeout. */
9204 error (_("Target does not support this command."));
9205 if (buf
[0] == 'O' && buf
[1] != 'K')
9207 remote_console_output (buf
+ 1); /* 'O' message from stub. */
9210 if (strcmp (buf
, "OK") == 0)
9212 if (strlen (buf
) == 3 && buf
[0] == 'E'
9213 && isdigit (buf
[1]) && isdigit (buf
[2]))
9215 error (_("Protocol error with Rcmd"));
9217 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
9219 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
9221 fputc_unfiltered (c
, outbuf
);
9227 static VEC(mem_region_s
) *
9228 remote_memory_map (struct target_ops
*ops
)
9230 VEC(mem_region_s
) *result
= NULL
;
9231 char *text
= target_read_stralloc (¤t_target
,
9232 TARGET_OBJECT_MEMORY_MAP
, NULL
);
9236 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
9238 result
= parse_memory_map (text
);
9239 do_cleanups (back_to
);
9246 packet_command (char *args
, int from_tty
)
9248 struct remote_state
*rs
= get_remote_state ();
9250 if (!rs
->remote_desc
)
9251 error (_("command can only be used with remote target"));
9254 error (_("remote-packet command requires packet text as argument"));
9256 puts_filtered ("sending: ");
9257 print_packet (args
);
9258 puts_filtered ("\n");
9261 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9262 puts_filtered ("received: ");
9263 print_packet (rs
->buf
);
9264 puts_filtered ("\n");
9268 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
9270 static void display_thread_info (struct gdb_ext_thread_info
*info
);
9272 static void threadset_test_cmd (char *cmd
, int tty
);
9274 static void threadalive_test (char *cmd
, int tty
);
9276 static void threadlist_test_cmd (char *cmd
, int tty
);
9278 int get_and_display_threadinfo (threadref
*ref
);
9280 static void threadinfo_test_cmd (char *cmd
, int tty
);
9282 static int thread_display_step (threadref
*ref
, void *context
);
9284 static void threadlist_update_test_cmd (char *cmd
, int tty
);
9286 static void init_remote_threadtests (void);
9288 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
9291 threadset_test_cmd (char *cmd
, int tty
)
9293 int sample_thread
= SAMPLE_THREAD
;
9295 printf_filtered (_("Remote threadset test\n"));
9296 set_general_thread (sample_thread
);
9301 threadalive_test (char *cmd
, int tty
)
9303 int sample_thread
= SAMPLE_THREAD
;
9304 int pid
= ptid_get_pid (inferior_ptid
);
9305 ptid_t ptid
= ptid_build (pid
, 0, sample_thread
);
9307 if (remote_thread_alive (ptid
))
9308 printf_filtered ("PASS: Thread alive test\n");
9310 printf_filtered ("FAIL: Thread alive test\n");
9313 void output_threadid (char *title
, threadref
*ref
);
9316 output_threadid (char *title
, threadref
*ref
)
9320 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
9322 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
9326 threadlist_test_cmd (char *cmd
, int tty
)
9329 threadref nextthread
;
9330 int done
, result_count
;
9331 threadref threadlist
[3];
9333 printf_filtered ("Remote Threadlist test\n");
9334 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
9335 &result_count
, &threadlist
[0]))
9336 printf_filtered ("FAIL: threadlist test\n");
9339 threadref
*scan
= threadlist
;
9340 threadref
*limit
= scan
+ result_count
;
9342 while (scan
< limit
)
9343 output_threadid (" thread ", scan
++);
9348 display_thread_info (struct gdb_ext_thread_info
*info
)
9350 output_threadid ("Threadid: ", &info
->threadid
);
9351 printf_filtered ("Name: %s\n ", info
->shortname
);
9352 printf_filtered ("State: %s\n", info
->display
);
9353 printf_filtered ("other: %s\n\n", info
->more_display
);
9357 get_and_display_threadinfo (threadref
*ref
)
9361 struct gdb_ext_thread_info threadinfo
;
9363 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
9364 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
9365 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
9366 display_thread_info (&threadinfo
);
9371 threadinfo_test_cmd (char *cmd
, int tty
)
9373 int athread
= SAMPLE_THREAD
;
9377 int_to_threadref (&thread
, athread
);
9378 printf_filtered ("Remote Threadinfo test\n");
9379 if (!get_and_display_threadinfo (&thread
))
9380 printf_filtered ("FAIL cannot get thread info\n");
9384 thread_display_step (threadref
*ref
, void *context
)
9386 /* output_threadid(" threadstep ",ref); *//* simple test */
9387 return get_and_display_threadinfo (ref
);
9391 threadlist_update_test_cmd (char *cmd
, int tty
)
9393 printf_filtered ("Remote Threadlist update test\n");
9394 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
9398 init_remote_threadtests (void)
9400 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
9401 _("Fetch and print the remote list of "
9402 "thread identifiers, one pkt only"));
9403 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
9404 _("Fetch and display info about one thread"));
9405 add_com ("tset", class_obscure
, threadset_test_cmd
,
9406 _("Test setting to a different thread"));
9407 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
9408 _("Iterate through updating all remote thread info"));
9409 add_com ("talive", class_obscure
, threadalive_test
,
9410 _(" Remote thread alive test "));
9415 /* Convert a thread ID to a string. Returns the string in a static
9419 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
9421 static char buf
[64];
9422 struct remote_state
*rs
= get_remote_state ();
9424 if (ptid_equal (ptid
, null_ptid
))
9425 return normal_pid_to_str (ptid
);
9426 else if (ptid_is_pid (ptid
))
9428 /* Printing an inferior target id. */
9430 /* When multi-process extensions are off, there's no way in the
9431 remote protocol to know the remote process id, if there's any
9432 at all. There's one exception --- when we're connected with
9433 target extended-remote, and we manually attached to a process
9434 with "attach PID". We don't record anywhere a flag that
9435 allows us to distinguish that case from the case of
9436 connecting with extended-remote and the stub already being
9437 attached to a process, and reporting yes to qAttached, hence
9438 no smart special casing here. */
9439 if (!remote_multi_process_p (rs
))
9441 xsnprintf (buf
, sizeof buf
, "Remote target");
9445 return normal_pid_to_str (ptid
);
9449 if (ptid_equal (magic_null_ptid
, ptid
))
9450 xsnprintf (buf
, sizeof buf
, "Thread <main>");
9451 else if (rs
->extended
&& remote_multi_process_p (rs
))
9452 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
9453 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
9455 xsnprintf (buf
, sizeof buf
, "Thread %ld",
9456 ptid_get_tid (ptid
));
9461 /* Get the address of the thread local variable in OBJFILE which is
9462 stored at OFFSET within the thread local storage for thread PTID. */
9465 remote_get_thread_local_address (struct target_ops
*ops
,
9466 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
9468 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
9470 struct remote_state
*rs
= get_remote_state ();
9472 char *endp
= rs
->buf
+ get_remote_packet_size ();
9473 enum packet_result result
;
9475 strcpy (p
, "qGetTLSAddr:");
9477 p
= write_ptid (p
, endp
, ptid
);
9479 p
+= hexnumstr (p
, offset
);
9481 p
+= hexnumstr (p
, lm
);
9485 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9486 result
= packet_ok (rs
->buf
,
9487 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
9488 if (result
== PACKET_OK
)
9492 unpack_varlen_hex (rs
->buf
, &result
);
9495 else if (result
== PACKET_UNKNOWN
)
9496 throw_error (TLS_GENERIC_ERROR
,
9497 _("Remote target doesn't support qGetTLSAddr packet"));
9499 throw_error (TLS_GENERIC_ERROR
,
9500 _("Remote target failed to process qGetTLSAddr request"));
9503 throw_error (TLS_GENERIC_ERROR
,
9504 _("TLS not supported or disabled on this target"));
9509 /* Provide thread local base, i.e. Thread Information Block address.
9510 Returns 1 if ptid is found and thread_local_base is non zero. */
9513 remote_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
9515 if (remote_protocol_packets
[PACKET_qGetTIBAddr
].support
!= PACKET_DISABLE
)
9517 struct remote_state
*rs
= get_remote_state ();
9519 char *endp
= rs
->buf
+ get_remote_packet_size ();
9520 enum packet_result result
;
9522 strcpy (p
, "qGetTIBAddr:");
9524 p
= write_ptid (p
, endp
, ptid
);
9528 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9529 result
= packet_ok (rs
->buf
,
9530 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
9531 if (result
== PACKET_OK
)
9535 unpack_varlen_hex (rs
->buf
, &result
);
9537 *addr
= (CORE_ADDR
) result
;
9540 else if (result
== PACKET_UNKNOWN
)
9541 error (_("Remote target doesn't support qGetTIBAddr packet"));
9543 error (_("Remote target failed to process qGetTIBAddr request"));
9546 error (_("qGetTIBAddr not supported or disabled on this target"));
9551 /* Support for inferring a target description based on the current
9552 architecture and the size of a 'g' packet. While the 'g' packet
9553 can have any size (since optional registers can be left off the
9554 end), some sizes are easily recognizable given knowledge of the
9555 approximate architecture. */
9557 struct remote_g_packet_guess
9560 const struct target_desc
*tdesc
;
9562 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
9563 DEF_VEC_O(remote_g_packet_guess_s
);
9565 struct remote_g_packet_data
9567 VEC(remote_g_packet_guess_s
) *guesses
;
9570 static struct gdbarch_data
*remote_g_packet_data_handle
;
9573 remote_g_packet_data_init (struct obstack
*obstack
)
9575 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
9579 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
9580 const struct target_desc
*tdesc
)
9582 struct remote_g_packet_data
*data
9583 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
9584 struct remote_g_packet_guess new_guess
, *guess
;
9587 gdb_assert (tdesc
!= NULL
);
9590 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
9592 if (guess
->bytes
== bytes
)
9593 internal_error (__FILE__
, __LINE__
,
9594 _("Duplicate g packet description added for size %d"),
9597 new_guess
.bytes
= bytes
;
9598 new_guess
.tdesc
= tdesc
;
9599 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
9602 /* Return 1 if remote_read_description would do anything on this target
9603 and architecture, 0 otherwise. */
9606 remote_read_description_p (struct target_ops
*target
)
9608 struct remote_g_packet_data
*data
9609 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
);
9611 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
9617 static const struct target_desc
*
9618 remote_read_description (struct target_ops
*target
)
9620 struct remote_g_packet_data
*data
9621 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
);
9623 /* Do not try this during initial connection, when we do not know
9624 whether there is a running but stopped thread. */
9625 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
9628 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
9630 struct remote_g_packet_guess
*guess
;
9632 int bytes
= send_g_packet ();
9635 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
9637 if (guess
->bytes
== bytes
)
9638 return guess
->tdesc
;
9640 /* We discard the g packet. A minor optimization would be to
9641 hold on to it, and fill the register cache once we have selected
9642 an architecture, but it's too tricky to do safely. */
9648 /* Remote file transfer support. This is host-initiated I/O, not
9649 target-initiated; for target-initiated, see remote-fileio.c. */
9651 /* If *LEFT is at least the length of STRING, copy STRING to
9652 *BUFFER, update *BUFFER to point to the new end of the buffer, and
9653 decrease *LEFT. Otherwise raise an error. */
9656 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
9658 int len
= strlen (string
);
9661 error (_("Packet too long for target."));
9663 memcpy (*buffer
, string
, len
);
9667 /* NUL-terminate the buffer as a convenience, if there is
9673 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
9674 *BUFFER, update *BUFFER to point to the new end of the buffer, and
9675 decrease *LEFT. Otherwise raise an error. */
9678 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
9681 if (2 * len
> *left
)
9682 error (_("Packet too long for target."));
9684 bin2hex (bytes
, *buffer
, len
);
9688 /* NUL-terminate the buffer as a convenience, if there is
9694 /* If *LEFT is large enough, convert VALUE to hex and add it to
9695 *BUFFER, update *BUFFER to point to the new end of the buffer, and
9696 decrease *LEFT. Otherwise raise an error. */
9699 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
9701 int len
= hexnumlen (value
);
9704 error (_("Packet too long for target."));
9706 hexnumstr (*buffer
, value
);
9710 /* NUL-terminate the buffer as a convenience, if there is
9716 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
9717 value, *REMOTE_ERRNO to the remote error number or zero if none
9718 was included, and *ATTACHMENT to point to the start of the annex
9719 if any. The length of the packet isn't needed here; there may
9720 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
9722 Return 0 if the packet could be parsed, -1 if it could not. If
9723 -1 is returned, the other variables may not be initialized. */
9726 remote_hostio_parse_result (char *buffer
, int *retcode
,
9727 int *remote_errno
, char **attachment
)
9734 if (buffer
[0] != 'F')
9738 *retcode
= strtol (&buffer
[1], &p
, 16);
9739 if (errno
!= 0 || p
== &buffer
[1])
9742 /* Check for ",errno". */
9746 *remote_errno
= strtol (p
+ 1, &p2
, 16);
9747 if (errno
!= 0 || p
+ 1 == p2
)
9752 /* Check for ";attachment". If there is no attachment, the
9753 packet should end here. */
9756 *attachment
= p
+ 1;
9759 else if (*p
== '\0')
9765 /* Send a prepared I/O packet to the target and read its response.
9766 The prepared packet is in the global RS->BUF before this function
9767 is called, and the answer is there when we return.
9769 COMMAND_BYTES is the length of the request to send, which may include
9770 binary data. WHICH_PACKET is the packet configuration to check
9771 before attempting a packet. If an error occurs, *REMOTE_ERRNO
9772 is set to the error number and -1 is returned. Otherwise the value
9773 returned by the function is returned.
9775 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
9776 attachment is expected; an error will be reported if there's a
9777 mismatch. If one is found, *ATTACHMENT will be set to point into
9778 the packet buffer and *ATTACHMENT_LEN will be set to the
9779 attachment's length. */
9782 remote_hostio_send_command (int command_bytes
, int which_packet
,
9783 int *remote_errno
, char **attachment
,
9784 int *attachment_len
)
9786 struct remote_state
*rs
= get_remote_state ();
9787 int ret
, bytes_read
;
9788 char *attachment_tmp
;
9790 if (!rs
->remote_desc
9791 || remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
9793 *remote_errno
= FILEIO_ENOSYS
;
9797 putpkt_binary (rs
->buf
, command_bytes
);
9798 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
9800 /* If it timed out, something is wrong. Don't try to parse the
9804 *remote_errno
= FILEIO_EINVAL
;
9808 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
9811 *remote_errno
= FILEIO_EINVAL
;
9813 case PACKET_UNKNOWN
:
9814 *remote_errno
= FILEIO_ENOSYS
;
9820 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
9823 *remote_errno
= FILEIO_EINVAL
;
9827 /* Make sure we saw an attachment if and only if we expected one. */
9828 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
9829 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
9831 *remote_errno
= FILEIO_EINVAL
;
9835 /* If an attachment was found, it must point into the packet buffer;
9836 work out how many bytes there were. */
9837 if (attachment_tmp
!= NULL
)
9839 *attachment
= attachment_tmp
;
9840 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
9846 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
9847 remote file descriptor, or -1 if an error occurs (and set
9851 remote_hostio_open (const char *filename
, int flags
, int mode
,
9854 struct remote_state
*rs
= get_remote_state ();
9856 int left
= get_remote_packet_size () - 1;
9858 remote_buffer_add_string (&p
, &left
, "vFile:open:");
9860 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
9862 remote_buffer_add_string (&p
, &left
, ",");
9864 remote_buffer_add_int (&p
, &left
, flags
);
9865 remote_buffer_add_string (&p
, &left
, ",");
9867 remote_buffer_add_int (&p
, &left
, mode
);
9869 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
9870 remote_errno
, NULL
, NULL
);
9873 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
9874 Return the number of bytes written, or -1 if an error occurs (and
9875 set *REMOTE_ERRNO). */
9878 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
9879 ULONGEST offset
, int *remote_errno
)
9881 struct remote_state
*rs
= get_remote_state ();
9883 int left
= get_remote_packet_size ();
9886 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
9888 remote_buffer_add_int (&p
, &left
, fd
);
9889 remote_buffer_add_string (&p
, &left
, ",");
9891 remote_buffer_add_int (&p
, &left
, offset
);
9892 remote_buffer_add_string (&p
, &left
, ",");
9894 p
+= remote_escape_output (write_buf
, len
, (gdb_byte
*) p
, &out_len
,
9895 get_remote_packet_size () - (p
- rs
->buf
));
9897 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
9898 remote_errno
, NULL
, NULL
);
9901 /* Read up to LEN bytes FD on the remote target into READ_BUF
9902 Return the number of bytes read, or -1 if an error occurs (and
9903 set *REMOTE_ERRNO). */
9906 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
9907 ULONGEST offset
, int *remote_errno
)
9909 struct remote_state
*rs
= get_remote_state ();
9912 int left
= get_remote_packet_size ();
9913 int ret
, attachment_len
;
9916 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
9918 remote_buffer_add_int (&p
, &left
, fd
);
9919 remote_buffer_add_string (&p
, &left
, ",");
9921 remote_buffer_add_int (&p
, &left
, len
);
9922 remote_buffer_add_string (&p
, &left
, ",");
9924 remote_buffer_add_int (&p
, &left
, offset
);
9926 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
9927 remote_errno
, &attachment
,
9933 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
9935 if (read_len
!= ret
)
9936 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
9941 /* Close FD on the remote target. Return 0, or -1 if an error occurs
9942 (and set *REMOTE_ERRNO). */
9945 remote_hostio_close (int fd
, int *remote_errno
)
9947 struct remote_state
*rs
= get_remote_state ();
9949 int left
= get_remote_packet_size () - 1;
9951 remote_buffer_add_string (&p
, &left
, "vFile:close:");
9953 remote_buffer_add_int (&p
, &left
, fd
);
9955 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
9956 remote_errno
, NULL
, NULL
);
9959 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
9960 occurs (and set *REMOTE_ERRNO). */
9963 remote_hostio_unlink (const char *filename
, int *remote_errno
)
9965 struct remote_state
*rs
= get_remote_state ();
9967 int left
= get_remote_packet_size () - 1;
9969 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
9971 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
9974 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
9975 remote_errno
, NULL
, NULL
);
9978 /* Read value of symbolic link FILENAME on the remote target. Return
9979 a null-terminated string allocated via xmalloc, or NULL if an error
9980 occurs (and set *REMOTE_ERRNO). */
9983 remote_hostio_readlink (const char *filename
, int *remote_errno
)
9985 struct remote_state
*rs
= get_remote_state ();
9988 int left
= get_remote_packet_size ();
9989 int len
, attachment_len
;
9993 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
9995 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
9998 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
9999 remote_errno
, &attachment
,
10005 ret
= xmalloc (len
+ 1);
10007 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
10008 (gdb_byte
*) ret
, len
);
10009 if (read_len
!= len
)
10010 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
10017 remote_fileio_errno_to_host (int errnum
)
10023 case FILEIO_ENOENT
:
10031 case FILEIO_EACCES
:
10033 case FILEIO_EFAULT
:
10037 case FILEIO_EEXIST
:
10039 case FILEIO_ENODEV
:
10041 case FILEIO_ENOTDIR
:
10043 case FILEIO_EISDIR
:
10045 case FILEIO_EINVAL
:
10047 case FILEIO_ENFILE
:
10049 case FILEIO_EMFILE
:
10053 case FILEIO_ENOSPC
:
10055 case FILEIO_ESPIPE
:
10059 case FILEIO_ENOSYS
:
10061 case FILEIO_ENAMETOOLONG
:
10062 return ENAMETOOLONG
;
10068 remote_hostio_error (int errnum
)
10070 int host_error
= remote_fileio_errno_to_host (errnum
);
10072 if (host_error
== -1)
10073 error (_("Unknown remote I/O error %d"), errnum
);
10075 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
10079 remote_hostio_close_cleanup (void *opaque
)
10081 int fd
= *(int *) opaque
;
10084 remote_hostio_close (fd
, &remote_errno
);
10089 remote_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
10091 const char *filename
= bfd_get_filename (abfd
);
10092 int fd
, remote_errno
;
10095 gdb_assert (remote_filename_p (filename
));
10097 fd
= remote_hostio_open (filename
+ 7, FILEIO_O_RDONLY
, 0, &remote_errno
);
10100 errno
= remote_fileio_errno_to_host (remote_errno
);
10101 bfd_set_error (bfd_error_system_call
);
10105 stream
= xmalloc (sizeof (int));
10111 remote_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
10113 int fd
= *(int *)stream
;
10118 /* Ignore errors on close; these may happen if the remote
10119 connection was already torn down. */
10120 remote_hostio_close (fd
, &remote_errno
);
10122 /* Zero means success. */
10127 remote_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
10128 file_ptr nbytes
, file_ptr offset
)
10130 int fd
= *(int *)stream
;
10132 file_ptr pos
, bytes
;
10135 while (nbytes
> pos
)
10137 bytes
= remote_hostio_pread (fd
, (gdb_byte
*) buf
+ pos
, nbytes
- pos
,
10138 offset
+ pos
, &remote_errno
);
10140 /* Success, but no bytes, means end-of-file. */
10144 errno
= remote_fileio_errno_to_host (remote_errno
);
10145 bfd_set_error (bfd_error_system_call
);
10156 remote_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
10158 /* FIXME: We should probably implement remote_hostio_stat. */
10159 sb
->st_size
= INT_MAX
;
10164 remote_filename_p (const char *filename
)
10166 return strncmp (filename
,
10167 REMOTE_SYSROOT_PREFIX
,
10168 sizeof (REMOTE_SYSROOT_PREFIX
) - 1) == 0;
10172 remote_bfd_open (const char *remote_file
, const char *target
)
10174 bfd
*abfd
= gdb_bfd_openr_iovec (remote_file
, target
,
10175 remote_bfd_iovec_open
, NULL
,
10176 remote_bfd_iovec_pread
,
10177 remote_bfd_iovec_close
,
10178 remote_bfd_iovec_stat
);
10184 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
10186 struct cleanup
*back_to
, *close_cleanup
;
10187 int retcode
, fd
, remote_errno
, bytes
, io_size
;
10190 int bytes_in_buffer
;
10193 struct remote_state
*rs
= get_remote_state ();
10195 if (!rs
->remote_desc
)
10196 error (_("command can only be used with remote target"));
10198 file
= gdb_fopen_cloexec (local_file
, "rb");
10200 perror_with_name (local_file
);
10201 back_to
= make_cleanup_fclose (file
);
10203 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
10205 0700, &remote_errno
);
10207 remote_hostio_error (remote_errno
);
10209 /* Send up to this many bytes at once. They won't all fit in the
10210 remote packet limit, so we'll transfer slightly fewer. */
10211 io_size
= get_remote_packet_size ();
10212 buffer
= xmalloc (io_size
);
10213 make_cleanup (xfree
, buffer
);
10215 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
10217 bytes_in_buffer
= 0;
10220 while (bytes_in_buffer
|| !saw_eof
)
10224 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
10225 io_size
- bytes_in_buffer
,
10230 error (_("Error reading %s."), local_file
);
10233 /* EOF. Unless there is something still in the
10234 buffer from the last iteration, we are done. */
10236 if (bytes_in_buffer
== 0)
10244 bytes
+= bytes_in_buffer
;
10245 bytes_in_buffer
= 0;
10247 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
,
10248 offset
, &remote_errno
);
10251 remote_hostio_error (remote_errno
);
10252 else if (retcode
== 0)
10253 error (_("Remote write of %d bytes returned 0!"), bytes
);
10254 else if (retcode
< bytes
)
10256 /* Short write. Save the rest of the read data for the next
10258 bytes_in_buffer
= bytes
- retcode
;
10259 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
10265 discard_cleanups (close_cleanup
);
10266 if (remote_hostio_close (fd
, &remote_errno
))
10267 remote_hostio_error (remote_errno
);
10270 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
10271 do_cleanups (back_to
);
10275 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
10277 struct cleanup
*back_to
, *close_cleanup
;
10278 int fd
, remote_errno
, bytes
, io_size
;
10282 struct remote_state
*rs
= get_remote_state ();
10284 if (!rs
->remote_desc
)
10285 error (_("command can only be used with remote target"));
10287 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
10289 remote_hostio_error (remote_errno
);
10291 file
= gdb_fopen_cloexec (local_file
, "wb");
10293 perror_with_name (local_file
);
10294 back_to
= make_cleanup_fclose (file
);
10296 /* Send up to this many bytes at once. They won't all fit in the
10297 remote packet limit, so we'll transfer slightly fewer. */
10298 io_size
= get_remote_packet_size ();
10299 buffer
= xmalloc (io_size
);
10300 make_cleanup (xfree
, buffer
);
10302 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
10307 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
10309 /* Success, but no bytes, means end-of-file. */
10312 remote_hostio_error (remote_errno
);
10316 bytes
= fwrite (buffer
, 1, bytes
, file
);
10318 perror_with_name (local_file
);
10321 discard_cleanups (close_cleanup
);
10322 if (remote_hostio_close (fd
, &remote_errno
))
10323 remote_hostio_error (remote_errno
);
10326 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
10327 do_cleanups (back_to
);
10331 remote_file_delete (const char *remote_file
, int from_tty
)
10333 int retcode
, remote_errno
;
10334 struct remote_state
*rs
= get_remote_state ();
10336 if (!rs
->remote_desc
)
10337 error (_("command can only be used with remote target"));
10339 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
10341 remote_hostio_error (remote_errno
);
10344 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
10348 remote_put_command (char *args
, int from_tty
)
10350 struct cleanup
*back_to
;
10354 error_no_arg (_("file to put"));
10356 argv
= gdb_buildargv (args
);
10357 back_to
= make_cleanup_freeargv (argv
);
10358 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
10359 error (_("Invalid parameters to remote put"));
10361 remote_file_put (argv
[0], argv
[1], from_tty
);
10363 do_cleanups (back_to
);
10367 remote_get_command (char *args
, int from_tty
)
10369 struct cleanup
*back_to
;
10373 error_no_arg (_("file to get"));
10375 argv
= gdb_buildargv (args
);
10376 back_to
= make_cleanup_freeargv (argv
);
10377 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
10378 error (_("Invalid parameters to remote get"));
10380 remote_file_get (argv
[0], argv
[1], from_tty
);
10382 do_cleanups (back_to
);
10386 remote_delete_command (char *args
, int from_tty
)
10388 struct cleanup
*back_to
;
10392 error_no_arg (_("file to delete"));
10394 argv
= gdb_buildargv (args
);
10395 back_to
= make_cleanup_freeargv (argv
);
10396 if (argv
[0] == NULL
|| argv
[1] != NULL
)
10397 error (_("Invalid parameters to remote delete"));
10399 remote_file_delete (argv
[0], from_tty
);
10401 do_cleanups (back_to
);
10405 remote_command (char *args
, int from_tty
)
10407 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
10411 remote_can_execute_reverse (void)
10413 if (remote_protocol_packets
[PACKET_bs
].support
== PACKET_ENABLE
10414 || remote_protocol_packets
[PACKET_bc
].support
== PACKET_ENABLE
)
10421 remote_supports_non_stop (void)
10427 remote_supports_disable_randomization (void)
10429 /* Only supported in extended mode. */
10434 remote_supports_multi_process (void)
10436 struct remote_state
*rs
= get_remote_state ();
10438 /* Only extended-remote handles being attached to multiple
10439 processes, even though plain remote can use the multi-process
10440 thread id extensions, so that GDB knows the target process's
10442 return rs
->extended
&& remote_multi_process_p (rs
);
10446 remote_supports_cond_tracepoints (void)
10448 struct remote_state
*rs
= get_remote_state ();
10450 return rs
->cond_tracepoints
;
10454 remote_supports_cond_breakpoints (void)
10456 struct remote_state
*rs
= get_remote_state ();
10458 return rs
->cond_breakpoints
;
10462 remote_supports_fast_tracepoints (void)
10464 struct remote_state
*rs
= get_remote_state ();
10466 return rs
->fast_tracepoints
;
10470 remote_supports_static_tracepoints (void)
10472 struct remote_state
*rs
= get_remote_state ();
10474 return rs
->static_tracepoints
;
10478 remote_supports_install_in_trace (void)
10480 struct remote_state
*rs
= get_remote_state ();
10482 return rs
->install_in_trace
;
10486 remote_supports_enable_disable_tracepoint (void)
10488 struct remote_state
*rs
= get_remote_state ();
10490 return rs
->enable_disable_tracepoints
;
10494 remote_supports_string_tracing (void)
10496 struct remote_state
*rs
= get_remote_state ();
10498 return rs
->string_tracing
;
10502 remote_can_run_breakpoint_commands (void)
10504 struct remote_state
*rs
= get_remote_state ();
10506 return rs
->breakpoint_commands
;
10510 remote_trace_init (void)
10513 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10514 if (strcmp (target_buf
, "OK") != 0)
10515 error (_("Target does not support this command."));
10518 static void free_actions_list (char **actions_list
);
10519 static void free_actions_list_cleanup_wrapper (void *);
10521 free_actions_list_cleanup_wrapper (void *al
)
10523 free_actions_list (al
);
10527 free_actions_list (char **actions_list
)
10531 if (actions_list
== 0)
10534 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
10535 xfree (actions_list
[ndx
]);
10537 xfree (actions_list
);
10540 /* Recursive routine to walk through command list including loops, and
10541 download packets for each command. */
10544 remote_download_command_source (int num
, ULONGEST addr
,
10545 struct command_line
*cmds
)
10547 struct remote_state
*rs
= get_remote_state ();
10548 struct command_line
*cmd
;
10550 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
10552 QUIT
; /* Allow user to bail out with ^C. */
10553 strcpy (rs
->buf
, "QTDPsrc:");
10554 encode_source_string (num
, addr
, "cmd", cmd
->line
,
10555 rs
->buf
+ strlen (rs
->buf
),
10556 rs
->buf_size
- strlen (rs
->buf
));
10558 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10559 if (strcmp (target_buf
, "OK"))
10560 warning (_("Target does not support source download."));
10562 if (cmd
->control_type
== while_control
10563 || cmd
->control_type
== while_stepping_control
)
10565 remote_download_command_source (num
, addr
, *cmd
->body_list
);
10567 QUIT
; /* Allow user to bail out with ^C. */
10568 strcpy (rs
->buf
, "QTDPsrc:");
10569 encode_source_string (num
, addr
, "cmd", "end",
10570 rs
->buf
+ strlen (rs
->buf
),
10571 rs
->buf_size
- strlen (rs
->buf
));
10573 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10574 if (strcmp (target_buf
, "OK"))
10575 warning (_("Target does not support source download."));
10581 remote_download_tracepoint (struct bp_location
*loc
)
10583 #define BUF_SIZE 2048
10587 char buf
[BUF_SIZE
];
10588 char **tdp_actions
;
10589 char **stepping_actions
;
10591 struct cleanup
*old_chain
= NULL
;
10592 struct agent_expr
*aexpr
;
10593 struct cleanup
*aexpr_chain
= NULL
;
10595 struct breakpoint
*b
= loc
->owner
;
10596 struct tracepoint
*t
= (struct tracepoint
*) b
;
10598 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
10599 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
10601 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
10604 tpaddr
= loc
->address
;
10605 sprintf_vma (addrbuf
, tpaddr
);
10606 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
10607 addrbuf
, /* address */
10608 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
10609 t
->step_count
, t
->pass_count
);
10610 /* Fast tracepoints are mostly handled by the target, but we can
10611 tell the target how big of an instruction block should be moved
10613 if (b
->type
== bp_fast_tracepoint
)
10615 /* Only test for support at download time; we may not know
10616 target capabilities at definition time. */
10617 if (remote_supports_fast_tracepoints ())
10621 if (gdbarch_fast_tracepoint_valid_at (target_gdbarch (),
10622 tpaddr
, &isize
, NULL
))
10623 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
10626 /* If it passed validation at definition but fails now,
10627 something is very wrong. */
10628 internal_error (__FILE__
, __LINE__
,
10629 _("Fast tracepoint not "
10630 "valid during download"));
10633 /* Fast tracepoints are functionally identical to regular
10634 tracepoints, so don't take lack of support as a reason to
10635 give up on the trace run. */
10636 warning (_("Target does not support fast tracepoints, "
10637 "downloading %d as regular tracepoint"), b
->number
);
10639 else if (b
->type
== bp_static_tracepoint
)
10641 /* Only test for support at download time; we may not know
10642 target capabilities at definition time. */
10643 if (remote_supports_static_tracepoints ())
10645 struct static_tracepoint_marker marker
;
10647 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
10648 strcat (buf
, ":S");
10650 error (_("Static tracepoint not valid during download"));
10653 /* Fast tracepoints are functionally identical to regular
10654 tracepoints, so don't take lack of support as a reason
10655 to give up on the trace run. */
10656 error (_("Target does not support static tracepoints"));
10658 /* If the tracepoint has a conditional, make it into an agent
10659 expression and append to the definition. */
10662 /* Only test support at download time, we may not know target
10663 capabilities at definition time. */
10664 if (remote_supports_cond_tracepoints ())
10666 aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
);
10667 aexpr_chain
= make_cleanup_free_agent_expr (aexpr
);
10668 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
10670 pkt
= buf
+ strlen (buf
);
10671 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
10672 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
10674 do_cleanups (aexpr_chain
);
10677 warning (_("Target does not support conditional tracepoints, "
10678 "ignoring tp %d cond"), b
->number
);
10681 if (b
->commands
|| *default_collect
)
10684 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10685 if (strcmp (target_buf
, "OK"))
10686 error (_("Target does not support tracepoints."));
10688 /* do_single_steps (t); */
10691 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
10693 QUIT
; /* Allow user to bail out with ^C. */
10694 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
10695 b
->number
, addrbuf
, /* address */
10697 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
10700 remote_get_noisy_reply (&target_buf
,
10702 if (strcmp (target_buf
, "OK"))
10703 error (_("Error on target while setting tracepoints."));
10706 if (stepping_actions
)
10708 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
10710 QUIT
; /* Allow user to bail out with ^C. */
10711 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
10712 b
->number
, addrbuf
, /* address */
10713 ((ndx
== 0) ? "S" : ""),
10714 stepping_actions
[ndx
],
10715 (stepping_actions
[ndx
+ 1] ? "-" : ""));
10717 remote_get_noisy_reply (&target_buf
,
10719 if (strcmp (target_buf
, "OK"))
10720 error (_("Error on target while setting tracepoints."));
10724 if (remote_protocol_packets
[PACKET_TracepointSource
].support
10727 if (b
->addr_string
)
10729 strcpy (buf
, "QTDPsrc:");
10730 encode_source_string (b
->number
, loc
->address
,
10731 "at", b
->addr_string
, buf
+ strlen (buf
),
10732 2048 - strlen (buf
));
10735 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10736 if (strcmp (target_buf
, "OK"))
10737 warning (_("Target does not support source download."));
10739 if (b
->cond_string
)
10741 strcpy (buf
, "QTDPsrc:");
10742 encode_source_string (b
->number
, loc
->address
,
10743 "cond", b
->cond_string
, buf
+ strlen (buf
),
10744 2048 - strlen (buf
));
10746 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10747 if (strcmp (target_buf
, "OK"))
10748 warning (_("Target does not support source download."));
10750 remote_download_command_source (b
->number
, loc
->address
,
10751 breakpoint_commands (b
));
10754 do_cleanups (old_chain
);
10758 remote_can_download_tracepoint (void)
10760 struct remote_state
*rs
= get_remote_state ();
10761 struct trace_status
*ts
;
10764 /* Don't try to install tracepoints until we've relocated our
10765 symbols, and fetched and merged the target's tracepoint list with
10767 if (rs
->starting_up
)
10770 ts
= current_trace_status ();
10771 status
= remote_get_trace_status (ts
);
10773 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
10776 /* If we are in a tracing experiment, but remote stub doesn't support
10777 installing tracepoint in trace, we have to return. */
10778 if (!remote_supports_install_in_trace ())
10786 remote_download_trace_state_variable (struct trace_state_variable
*tsv
)
10788 struct remote_state
*rs
= get_remote_state ();
10791 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
10792 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
10794 p
= rs
->buf
+ strlen (rs
->buf
);
10795 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
10796 error (_("Trace state variable name too long for tsv definition packet"));
10797 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, 0);
10800 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10801 if (*target_buf
== '\0')
10802 error (_("Target does not support this command."));
10803 if (strcmp (target_buf
, "OK") != 0)
10804 error (_("Error on target while downloading trace state variable."));
10808 remote_enable_tracepoint (struct bp_location
*location
)
10810 struct remote_state
*rs
= get_remote_state ();
10813 sprintf_vma (addr_buf
, location
->address
);
10814 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
10815 location
->owner
->number
, addr_buf
);
10817 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
10818 if (*rs
->buf
== '\0')
10819 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
10820 if (strcmp (rs
->buf
, "OK") != 0)
10821 error (_("Error on target while enabling tracepoint."));
10825 remote_disable_tracepoint (struct bp_location
*location
)
10827 struct remote_state
*rs
= get_remote_state ();
10830 sprintf_vma (addr_buf
, location
->address
);
10831 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
10832 location
->owner
->number
, addr_buf
);
10834 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
10835 if (*rs
->buf
== '\0')
10836 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
10837 if (strcmp (rs
->buf
, "OK") != 0)
10838 error (_("Error on target while disabling tracepoint."));
10842 remote_trace_set_readonly_regions (void)
10846 bfd_size_type size
;
10852 return; /* No information to give. */
10854 strcpy (target_buf
, "QTro");
10855 offset
= strlen (target_buf
);
10856 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10858 char tmp1
[40], tmp2
[40];
10861 if ((s
->flags
& SEC_LOAD
) == 0 ||
10862 /* (s->flags & SEC_CODE) == 0 || */
10863 (s
->flags
& SEC_READONLY
) == 0)
10867 vma
= bfd_get_section_vma (abfd
, s
);
10868 size
= bfd_get_section_size (s
);
10869 sprintf_vma (tmp1
, vma
);
10870 sprintf_vma (tmp2
, vma
+ size
);
10871 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
10872 if (offset
+ sec_length
+ 1 > target_buf_size
)
10874 if (remote_protocol_packets
[PACKET_qXfer_traceframe_info
].support
10877 Too many sections for read-only sections definition packet."));
10880 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
10882 offset
+= sec_length
;
10886 putpkt (target_buf
);
10887 getpkt (&target_buf
, &target_buf_size
, 0);
10892 remote_trace_start (void)
10894 putpkt ("QTStart");
10895 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10896 if (*target_buf
== '\0')
10897 error (_("Target does not support this command."));
10898 if (strcmp (target_buf
, "OK") != 0)
10899 error (_("Bogus reply from target: %s"), target_buf
);
10903 remote_get_trace_status (struct trace_status
*ts
)
10905 /* Initialize it just to avoid a GCC false warning. */
10907 /* FIXME we need to get register block size some other way. */
10908 extern int trace_regblock_size
;
10909 volatile struct gdb_exception ex
;
10910 enum packet_result result
;
10912 if (remote_protocol_packets
[PACKET_qTStatus
].support
== PACKET_DISABLE
)
10915 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
10917 putpkt ("qTStatus");
10919 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
10921 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10925 if (ex
.error
!= TARGET_CLOSE_ERROR
)
10927 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
10930 throw_exception (ex
);
10933 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
10935 /* If the remote target doesn't do tracing, flag it. */
10936 if (result
== PACKET_UNKNOWN
)
10939 /* We're working with a live target. */
10940 ts
->filename
= NULL
;
10943 error (_("Bogus trace status reply from target: %s"), target_buf
);
10945 /* Function 'parse_trace_status' sets default value of each field of
10946 'ts' at first, so we don't have to do it here. */
10947 parse_trace_status (p
, ts
);
10949 return ts
->running
;
10953 remote_get_tracepoint_status (struct breakpoint
*bp
,
10954 struct uploaded_tp
*utp
)
10956 struct remote_state
*rs
= get_remote_state ();
10958 struct bp_location
*loc
;
10959 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
10960 size_t size
= get_remote_packet_size ();
10964 tp
->base
.hit_count
= 0;
10965 tp
->traceframe_usage
= 0;
10966 for (loc
= tp
->base
.loc
; loc
; loc
= loc
->next
)
10968 /* If the tracepoint was never downloaded, don't go asking for
10970 if (tp
->number_on_target
== 0)
10972 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
10973 phex_nz (loc
->address
, 0));
10975 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10976 if (reply
&& *reply
)
10979 parse_tracepoint_status (reply
+ 1, bp
, utp
);
10985 utp
->hit_count
= 0;
10986 utp
->traceframe_usage
= 0;
10987 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
10988 phex_nz (utp
->addr
, 0));
10990 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10991 if (reply
&& *reply
)
10994 parse_tracepoint_status (reply
+ 1, bp
, utp
);
11000 remote_trace_stop (void)
11003 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11004 if (*target_buf
== '\0')
11005 error (_("Target does not support this command."));
11006 if (strcmp (target_buf
, "OK") != 0)
11007 error (_("Bogus reply from target: %s"), target_buf
);
11011 remote_trace_find (enum trace_find_type type
, int num
,
11012 CORE_ADDR addr1
, CORE_ADDR addr2
,
11015 struct remote_state
*rs
= get_remote_state ();
11016 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11018 int target_frameno
= -1, target_tracept
= -1;
11020 /* Lookups other than by absolute frame number depend on the current
11021 trace selected, so make sure it is correct on the remote end
11023 if (type
!= tfind_number
)
11024 set_remote_traceframe ();
11027 strcpy (p
, "QTFrame:");
11028 p
= strchr (p
, '\0');
11032 xsnprintf (p
, endbuf
- p
, "%x", num
);
11035 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
11038 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
11041 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
11042 phex_nz (addr2
, 0));
11044 case tfind_outside
:
11045 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
11046 phex_nz (addr2
, 0));
11049 error (_("Unknown trace find type %d"), type
);
11053 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
11054 if (*reply
== '\0')
11055 error (_("Target does not support this command."));
11057 while (reply
&& *reply
)
11062 target_frameno
= (int) strtol (p
, &reply
, 16);
11064 error (_("Unable to parse trace frame number"));
11065 /* Don't update our remote traceframe number cache on failure
11066 to select a remote traceframe. */
11067 if (target_frameno
== -1)
11072 target_tracept
= (int) strtol (p
, &reply
, 16);
11074 error (_("Unable to parse tracepoint number"));
11076 case 'O': /* "OK"? */
11077 if (reply
[1] == 'K' && reply
[2] == '\0')
11080 error (_("Bogus reply from target: %s"), reply
);
11083 error (_("Bogus reply from target: %s"), reply
);
11086 *tpp
= target_tracept
;
11088 rs
->remote_traceframe_number
= target_frameno
;
11089 return target_frameno
;
11093 remote_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
11095 struct remote_state
*rs
= get_remote_state ();
11099 set_remote_traceframe ();
11101 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
11103 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11104 if (reply
&& *reply
)
11108 unpack_varlen_hex (reply
+ 1, &uval
);
11109 *val
= (LONGEST
) uval
;
11117 remote_save_trace_data (const char *filename
)
11119 struct remote_state
*rs
= get_remote_state ();
11123 strcpy (p
, "QTSave:");
11125 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
11126 error (_("Remote file name too long for trace save packet"));
11127 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, 0);
11130 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11131 if (*reply
== '\0')
11132 error (_("Target does not support this command."));
11133 if (strcmp (reply
, "OK") != 0)
11134 error (_("Bogus reply from target: %s"), reply
);
11138 /* This is basically a memory transfer, but needs to be its own packet
11139 because we don't know how the target actually organizes its trace
11140 memory, plus we want to be able to ask for as much as possible, but
11141 not be unhappy if we don't get as much as we ask for. */
11144 remote_get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
11146 struct remote_state
*rs
= get_remote_state ();
11152 strcpy (p
, "qTBuffer:");
11154 p
+= hexnumstr (p
, offset
);
11156 p
+= hexnumstr (p
, len
);
11160 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11161 if (reply
&& *reply
)
11163 /* 'l' by itself means we're at the end of the buffer and
11164 there is nothing more to get. */
11168 /* Convert the reply into binary. Limit the number of bytes to
11169 convert according to our passed-in buffer size, rather than
11170 what was returned in the packet; if the target is
11171 unexpectedly generous and gives us a bigger reply than we
11172 asked for, we don't want to crash. */
11173 rslt
= hex2bin (target_buf
, buf
, len
);
11177 /* Something went wrong, flag as an error. */
11182 remote_set_disconnected_tracing (int val
)
11184 struct remote_state
*rs
= get_remote_state ();
11186 if (rs
->disconnected_tracing
)
11190 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
11192 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11193 if (*reply
== '\0')
11194 error (_("Target does not support this command."));
11195 if (strcmp (reply
, "OK") != 0)
11196 error (_("Bogus reply from target: %s"), reply
);
11199 warning (_("Target does not support disconnected tracing."));
11203 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
11205 struct thread_info
*info
= find_thread_ptid (ptid
);
11207 if (info
&& info
->private)
11208 return info
->private->core
;
11213 remote_set_circular_trace_buffer (int val
)
11215 struct remote_state
*rs
= get_remote_state ();
11218 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
11220 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11221 if (*reply
== '\0')
11222 error (_("Target does not support this command."));
11223 if (strcmp (reply
, "OK") != 0)
11224 error (_("Bogus reply from target: %s"), reply
);
11227 static struct traceframe_info
*
11228 remote_traceframe_info (void)
11232 /* If current traceframe is not selected, don't bother the remote
11234 if (get_traceframe_number () < 0)
11237 text
= target_read_stralloc (¤t_target
,
11238 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
11241 struct traceframe_info
*info
;
11242 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
11244 info
= parse_traceframe_info (text
);
11245 do_cleanups (back_to
);
11252 /* Handle the qTMinFTPILen packet. Returns the minimum length of
11253 instruction on which a fast tracepoint may be placed. Returns -1
11254 if the packet is not supported, and 0 if the minimum instruction
11255 length is unknown. */
11258 remote_get_min_fast_tracepoint_insn_len (void)
11260 struct remote_state
*rs
= get_remote_state ();
11263 /* If we're not debugging a process yet, the IPA can't be
11265 if (!target_has_execution
)
11268 /* Make sure the remote is pointing at the right process. */
11269 set_general_process ();
11271 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
11273 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11274 if (*reply
== '\0')
11278 ULONGEST min_insn_len
;
11280 unpack_varlen_hex (reply
, &min_insn_len
);
11282 return (int) min_insn_len
;
11287 remote_set_trace_buffer_size (LONGEST val
)
11289 if (remote_protocol_packets
[PACKET_QTBuffer_size
].support
11292 struct remote_state
*rs
= get_remote_state ();
11293 char *buf
= rs
->buf
;
11294 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11295 enum packet_result result
;
11297 gdb_assert (val
>= 0 || val
== -1);
11298 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
11299 /* Send -1 as literal "-1" to avoid host size dependency. */
11303 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
11306 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
11309 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
11310 result
= packet_ok (rs
->buf
,
11311 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
11313 if (result
!= PACKET_OK
)
11314 warning (_("Bogus reply from target: %s"), rs
->buf
);
11319 remote_set_trace_notes (const char *user
, const char *notes
,
11320 const char *stop_notes
)
11322 struct remote_state
*rs
= get_remote_state ();
11324 char *buf
= rs
->buf
;
11325 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11328 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
11331 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
11332 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, 0);
11338 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
11339 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, 0);
11345 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
11346 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, 0);
11350 /* Ensure the buffer is terminated. */
11354 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11355 if (*reply
== '\0')
11358 if (strcmp (reply
, "OK") != 0)
11359 error (_("Bogus reply from target: %s"), reply
);
11365 remote_use_agent (int use
)
11367 if (remote_protocol_packets
[PACKET_QAgent
].support
!= PACKET_DISABLE
)
11369 struct remote_state
*rs
= get_remote_state ();
11371 /* If the stub supports QAgent. */
11372 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
11374 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11376 if (strcmp (rs
->buf
, "OK") == 0)
11387 remote_can_use_agent (void)
11389 return (remote_protocol_packets
[PACKET_QAgent
].support
!= PACKET_DISABLE
);
11392 struct btrace_target_info
11394 /* The ptid of the traced thread. */
11398 /* Check whether the target supports branch tracing. */
11401 remote_supports_btrace (void)
11403 if (remote_protocol_packets
[PACKET_Qbtrace_off
].support
!= PACKET_ENABLE
)
11405 if (remote_protocol_packets
[PACKET_Qbtrace_bts
].support
!= PACKET_ENABLE
)
11407 if (remote_protocol_packets
[PACKET_qXfer_btrace
].support
!= PACKET_ENABLE
)
11413 /* Enable branch tracing. */
11415 static struct btrace_target_info
*
11416 remote_enable_btrace (ptid_t ptid
)
11418 struct btrace_target_info
*tinfo
= NULL
;
11419 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
11420 struct remote_state
*rs
= get_remote_state ();
11421 char *buf
= rs
->buf
;
11422 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11424 if (packet
->support
!= PACKET_ENABLE
)
11425 error (_("Target does not support branch tracing."));
11427 set_general_thread (ptid
);
11429 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
11431 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11433 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
11435 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
11436 error (_("Could not enable branch tracing for %s: %s"),
11437 target_pid_to_str (ptid
), rs
->buf
+ 2);
11439 error (_("Could not enable branch tracing for %s."),
11440 target_pid_to_str (ptid
));
11443 tinfo
= xzalloc (sizeof (*tinfo
));
11444 tinfo
->ptid
= ptid
;
11449 /* Disable branch tracing. */
11452 remote_disable_btrace (struct btrace_target_info
*tinfo
)
11454 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
11455 struct remote_state
*rs
= get_remote_state ();
11456 char *buf
= rs
->buf
;
11457 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11459 if (packet
->support
!= PACKET_ENABLE
)
11460 error (_("Target does not support branch tracing."));
11462 set_general_thread (tinfo
->ptid
);
11464 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
11466 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11468 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
11470 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
11471 error (_("Could not disable branch tracing for %s: %s"),
11472 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
11474 error (_("Could not disable branch tracing for %s."),
11475 target_pid_to_str (tinfo
->ptid
));
11481 /* Teardown branch tracing. */
11484 remote_teardown_btrace (struct btrace_target_info
*tinfo
)
11486 /* We must not talk to the target during teardown. */
11490 /* Read the branch trace. */
11492 static enum btrace_error
11493 remote_read_btrace (VEC (btrace_block_s
) **btrace
,
11494 struct btrace_target_info
*tinfo
,
11495 enum btrace_read_type type
)
11497 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
11498 struct remote_state
*rs
= get_remote_state ();
11499 struct cleanup
*cleanup
;
11503 if (packet
->support
!= PACKET_ENABLE
)
11504 error (_("Target does not support branch tracing."));
11506 #if !defined(HAVE_LIBEXPAT)
11507 error (_("Cannot process branch tracing result. XML parsing not supported."));
11512 case BTRACE_READ_ALL
:
11515 case BTRACE_READ_NEW
:
11518 case BTRACE_READ_DELTA
:
11522 internal_error (__FILE__
, __LINE__
,
11523 _("Bad branch tracing read type: %u."),
11524 (unsigned int) type
);
11527 xml
= target_read_stralloc (¤t_target
,
11528 TARGET_OBJECT_BTRACE
, annex
);
11530 return BTRACE_ERR_UNKNOWN
;
11532 cleanup
= make_cleanup (xfree
, xml
);
11533 *btrace
= parse_xml_btrace (xml
);
11534 do_cleanups (cleanup
);
11536 return BTRACE_ERR_NONE
;
11540 remote_augmented_libraries_svr4_read (void)
11542 struct remote_state
*rs
= get_remote_state ();
11544 return rs
->augmented_libraries_svr4_read
;
11548 init_remote_ops (void)
11550 remote_ops
.to_shortname
= "remote";
11551 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
11552 remote_ops
.to_doc
=
11553 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
11554 Specify the serial device it is connected to\n\
11555 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
11556 remote_ops
.to_open
= remote_open
;
11557 remote_ops
.to_close
= remote_close
;
11558 remote_ops
.to_detach
= remote_detach
;
11559 remote_ops
.to_disconnect
= remote_disconnect
;
11560 remote_ops
.to_resume
= remote_resume
;
11561 remote_ops
.to_wait
= remote_wait
;
11562 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
11563 remote_ops
.to_store_registers
= remote_store_registers
;
11564 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
11565 remote_ops
.to_files_info
= remote_files_info
;
11566 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
11567 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
11568 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
11569 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
11570 remote_ops
.to_watchpoint_addr_within_range
=
11571 remote_watchpoint_addr_within_range
;
11572 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
11573 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
11574 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
11575 remote_ops
.to_region_ok_for_hw_watchpoint
11576 = remote_region_ok_for_hw_watchpoint
;
11577 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
11578 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
11579 remote_ops
.to_kill
= remote_kill
;
11580 remote_ops
.to_load
= generic_load
;
11581 remote_ops
.to_mourn_inferior
= remote_mourn
;
11582 remote_ops
.to_pass_signals
= remote_pass_signals
;
11583 remote_ops
.to_program_signals
= remote_program_signals
;
11584 remote_ops
.to_thread_alive
= remote_thread_alive
;
11585 remote_ops
.to_find_new_threads
= remote_threads_info
;
11586 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
11587 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
11588 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
11589 remote_ops
.to_stop
= remote_stop
;
11590 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
11591 remote_ops
.to_rcmd
= remote_rcmd
;
11592 remote_ops
.to_log_command
= serial_log_command
;
11593 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
11594 remote_ops
.to_stratum
= process_stratum
;
11595 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
11596 remote_ops
.to_has_memory
= default_child_has_memory
;
11597 remote_ops
.to_has_stack
= default_child_has_stack
;
11598 remote_ops
.to_has_registers
= default_child_has_registers
;
11599 remote_ops
.to_has_execution
= default_child_has_execution
;
11600 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
11601 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
11602 remote_ops
.to_magic
= OPS_MAGIC
;
11603 remote_ops
.to_memory_map
= remote_memory_map
;
11604 remote_ops
.to_flash_erase
= remote_flash_erase
;
11605 remote_ops
.to_flash_done
= remote_flash_done
;
11606 remote_ops
.to_read_description
= remote_read_description
;
11607 remote_ops
.to_search_memory
= remote_search_memory
;
11608 remote_ops
.to_can_async_p
= remote_can_async_p
;
11609 remote_ops
.to_is_async_p
= remote_is_async_p
;
11610 remote_ops
.to_async
= remote_async
;
11611 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
11612 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
11613 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
11614 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
11615 remote_ops
.to_supports_disable_randomization
11616 = remote_supports_disable_randomization
;
11617 remote_ops
.to_fileio_open
= remote_hostio_open
;
11618 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
11619 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
11620 remote_ops
.to_fileio_close
= remote_hostio_close
;
11621 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
11622 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
11623 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
11624 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
11625 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
11626 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
11627 remote_ops
.to_trace_init
= remote_trace_init
;
11628 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
11629 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
11630 remote_ops
.to_download_trace_state_variable
11631 = remote_download_trace_state_variable
;
11632 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
11633 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
11634 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
11635 remote_ops
.to_trace_start
= remote_trace_start
;
11636 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
11637 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
11638 remote_ops
.to_trace_stop
= remote_trace_stop
;
11639 remote_ops
.to_trace_find
= remote_trace_find
;
11640 remote_ops
.to_get_trace_state_variable_value
11641 = remote_get_trace_state_variable_value
;
11642 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
11643 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
11644 remote_ops
.to_upload_trace_state_variables
11645 = remote_upload_trace_state_variables
;
11646 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
11647 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
11648 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
11649 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
11650 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
11651 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
11652 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
11653 remote_ops
.to_verify_memory
= remote_verify_memory
;
11654 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
11655 remote_ops
.to_set_permissions
= remote_set_permissions
;
11656 remote_ops
.to_static_tracepoint_marker_at
11657 = remote_static_tracepoint_marker_at
;
11658 remote_ops
.to_static_tracepoint_markers_by_strid
11659 = remote_static_tracepoint_markers_by_strid
;
11660 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
11661 remote_ops
.to_use_agent
= remote_use_agent
;
11662 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
11663 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
11664 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
11665 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
11666 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
11667 remote_ops
.to_read_btrace
= remote_read_btrace
;
11668 remote_ops
.to_augmented_libraries_svr4_read
=
11669 remote_augmented_libraries_svr4_read
;
11672 /* Set up the extended remote vector by making a copy of the standard
11673 remote vector and adding to it. */
11676 init_extended_remote_ops (void)
11678 extended_remote_ops
= remote_ops
;
11680 extended_remote_ops
.to_shortname
= "extended-remote";
11681 extended_remote_ops
.to_longname
=
11682 "Extended remote serial target in gdb-specific protocol";
11683 extended_remote_ops
.to_doc
=
11684 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
11685 Specify the serial device it is connected to (e.g. /dev/ttya).";
11686 extended_remote_ops
.to_open
= extended_remote_open
;
11687 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
11688 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
11689 extended_remote_ops
.to_detach
= extended_remote_detach
;
11690 extended_remote_ops
.to_attach
= extended_remote_attach
;
11691 extended_remote_ops
.to_kill
= extended_remote_kill
;
11692 extended_remote_ops
.to_supports_disable_randomization
11693 = extended_remote_supports_disable_randomization
;
11697 remote_can_async_p (void)
11699 struct remote_state
*rs
= get_remote_state ();
11701 if (!target_async_permitted
)
11702 /* We only enable async when the user specifically asks for it. */
11705 /* We're async whenever the serial device is. */
11706 return serial_can_async_p (rs
->remote_desc
);
11710 remote_is_async_p (void)
11712 struct remote_state
*rs
= get_remote_state ();
11714 if (!target_async_permitted
)
11715 /* We only enable async when the user specifically asks for it. */
11718 /* We're async whenever the serial device is. */
11719 return serial_is_async_p (rs
->remote_desc
);
11722 /* Pass the SERIAL event on and up to the client. One day this code
11723 will be able to delay notifying the client of an event until the
11724 point where an entire packet has been received. */
11726 static serial_event_ftype remote_async_serial_handler
;
11729 remote_async_serial_handler (struct serial
*scb
, void *context
)
11731 struct remote_state
*rs
= context
;
11733 /* Don't propogate error information up to the client. Instead let
11734 the client find out about the error by querying the target. */
11735 rs
->async_client_callback (INF_REG_EVENT
, rs
->async_client_context
);
11739 remote_async_inferior_event_handler (gdb_client_data data
)
11741 inferior_event_handler (INF_REG_EVENT
, NULL
);
11745 remote_async (void (*callback
) (enum inferior_event_type event_type
,
11746 void *context
), void *context
)
11748 struct remote_state
*rs
= get_remote_state ();
11750 if (callback
!= NULL
)
11752 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
11753 rs
->async_client_callback
= callback
;
11754 rs
->async_client_context
= context
;
11757 serial_async (rs
->remote_desc
, NULL
, NULL
);
11761 set_remote_cmd (char *args
, int from_tty
)
11763 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
11767 show_remote_cmd (char *args
, int from_tty
)
11769 /* We can't just use cmd_show_list here, because we want to skip
11770 the redundant "show remote Z-packet" and the legacy aliases. */
11771 struct cleanup
*showlist_chain
;
11772 struct cmd_list_element
*list
= remote_show_cmdlist
;
11773 struct ui_out
*uiout
= current_uiout
;
11775 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
11776 for (; list
!= NULL
; list
= list
->next
)
11777 if (strcmp (list
->name
, "Z-packet") == 0)
11779 else if (list
->type
== not_set_cmd
)
11780 /* Alias commands are exactly like the original, except they
11781 don't have the normal type. */
11785 struct cleanup
*option_chain
11786 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
11788 ui_out_field_string (uiout
, "name", list
->name
);
11789 ui_out_text (uiout
, ": ");
11790 if (list
->type
== show_cmd
)
11791 do_show_command ((char *) NULL
, from_tty
, list
);
11793 cmd_func (list
, NULL
, from_tty
);
11794 /* Close the tuple. */
11795 do_cleanups (option_chain
);
11798 /* Close the tuple. */
11799 do_cleanups (showlist_chain
);
11803 /* Function to be called whenever a new objfile (shlib) is detected. */
11805 remote_new_objfile (struct objfile
*objfile
)
11807 struct remote_state
*rs
= get_remote_state ();
11809 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
11810 remote_check_symbols ();
11813 /* Pull all the tracepoints defined on the target and create local
11814 data structures representing them. We don't want to create real
11815 tracepoints yet, we don't want to mess up the user's existing
11819 remote_upload_tracepoints (struct uploaded_tp
**utpp
)
11821 struct remote_state
*rs
= get_remote_state ();
11824 /* Ask for a first packet of tracepoint definition. */
11826 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11828 while (*p
&& *p
!= 'l')
11830 parse_tracepoint_definition (p
, utpp
);
11831 /* Ask for another packet of tracepoint definition. */
11833 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11840 remote_upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
11842 struct remote_state
*rs
= get_remote_state ();
11845 /* Ask for a first packet of variable definition. */
11847 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11849 while (*p
&& *p
!= 'l')
11851 parse_tsv_definition (p
, utsvp
);
11852 /* Ask for another packet of variable definition. */
11854 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11860 /* The "set/show range-stepping" show hook. */
11863 show_range_stepping (struct ui_file
*file
, int from_tty
,
11864 struct cmd_list_element
*c
,
11867 fprintf_filtered (file
,
11868 _("Debugger's willingness to use range stepping "
11869 "is %s.\n"), value
);
11872 /* The "set/show range-stepping" set hook. */
11875 set_range_stepping (char *ignore_args
, int from_tty
,
11876 struct cmd_list_element
*c
)
11878 struct remote_state
*rs
= get_remote_state ();
11880 /* Whene enabling, check whether range stepping is actually
11881 supported by the target, and warn if not. */
11882 if (use_range_stepping
)
11884 if (rs
->remote_desc
!= NULL
)
11886 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
11887 remote_vcont_probe (rs
);
11889 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_ENABLE
11890 && rs
->supports_vCont
.r
)
11894 warning (_("Range stepping is not supported by the current target"));
11899 _initialize_remote (void)
11901 struct remote_state
*rs
;
11902 struct cmd_list_element
*cmd
;
11903 const char *cmd_name
;
11905 /* architecture specific data */
11906 remote_gdbarch_data_handle
=
11907 gdbarch_data_register_post_init (init_remote_state
);
11908 remote_g_packet_data_handle
=
11909 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
11911 /* Initialize the per-target state. At the moment there is only one
11912 of these, not one per target. Only one target is active at a
11914 remote_state
= new_remote_state ();
11916 init_remote_ops ();
11917 add_target (&remote_ops
);
11919 init_extended_remote_ops ();
11920 add_target (&extended_remote_ops
);
11922 /* Hook into new objfile notification. */
11923 observer_attach_new_objfile (remote_new_objfile
);
11924 /* We're no longer interested in notification events of an inferior
11926 observer_attach_inferior_exit (discard_pending_stop_replies
);
11928 /* Set up signal handlers. */
11929 async_sigint_remote_token
=
11930 create_async_signal_handler (async_remote_interrupt
, NULL
);
11931 async_sigint_remote_twice_token
=
11932 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
11935 init_remote_threadtests ();
11938 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
11939 /* set/show remote ... */
11941 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
11942 Remote protocol specific variables\n\
11943 Configure various remote-protocol specific variables such as\n\
11944 the packets being used"),
11945 &remote_set_cmdlist
, "set remote ",
11946 0 /* allow-unknown */, &setlist
);
11947 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
11948 Remote protocol specific variables\n\
11949 Configure various remote-protocol specific variables such as\n\
11950 the packets being used"),
11951 &remote_show_cmdlist
, "show remote ",
11952 0 /* allow-unknown */, &showlist
);
11954 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
11955 Compare section data on target to the exec file.\n\
11956 Argument is a single section name (default: all loaded sections)."),
11959 add_cmd ("packet", class_maintenance
, packet_command
, _("\
11960 Send an arbitrary packet to a remote target.\n\
11961 maintenance packet TEXT\n\
11962 If GDB is talking to an inferior via the GDB serial protocol, then\n\
11963 this command sends the string TEXT to the inferior, and displays the\n\
11964 response packet. GDB supplies the initial `$' character, and the\n\
11965 terminating `#' character and checksum."),
11968 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
11969 Set whether to send break if interrupted."), _("\
11970 Show whether to send break if interrupted."), _("\
11971 If set, a break, instead of a cntrl-c, is sent to the remote target."),
11972 set_remotebreak
, show_remotebreak
,
11973 &setlist
, &showlist
);
11974 cmd_name
= "remotebreak";
11975 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
11976 deprecate_cmd (cmd
, "set remote interrupt-sequence");
11977 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
11978 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
11979 deprecate_cmd (cmd
, "show remote interrupt-sequence");
11981 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
11982 interrupt_sequence_modes
, &interrupt_sequence_mode
,
11984 Set interrupt sequence to remote target."), _("\
11985 Show interrupt sequence to remote target."), _("\
11986 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
11987 NULL
, show_interrupt_sequence
,
11988 &remote_set_cmdlist
,
11989 &remote_show_cmdlist
);
11991 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
11992 &interrupt_on_connect
, _("\
11993 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
11994 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
11995 If set, interrupt sequence is sent to remote target."),
11997 &remote_set_cmdlist
, &remote_show_cmdlist
);
11999 /* Install commands for configuring memory read/write packets. */
12001 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
12002 Set the maximum number of bytes per memory write packet (deprecated)."),
12004 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
12005 Show the maximum number of bytes per memory write packet (deprecated)."),
12007 add_cmd ("memory-write-packet-size", no_class
,
12008 set_memory_write_packet_size
, _("\
12009 Set the maximum number of bytes per memory-write packet.\n\
12010 Specify the number of bytes in a packet or 0 (zero) for the\n\
12011 default packet size. The actual limit is further reduced\n\
12012 dependent on the target. Specify ``fixed'' to disable the\n\
12013 further restriction and ``limit'' to enable that restriction."),
12014 &remote_set_cmdlist
);
12015 add_cmd ("memory-read-packet-size", no_class
,
12016 set_memory_read_packet_size
, _("\
12017 Set the maximum number of bytes per memory-read packet.\n\
12018 Specify the number of bytes in a packet or 0 (zero) for the\n\
12019 default packet size. The actual limit is further reduced\n\
12020 dependent on the target. Specify ``fixed'' to disable the\n\
12021 further restriction and ``limit'' to enable that restriction."),
12022 &remote_set_cmdlist
);
12023 add_cmd ("memory-write-packet-size", no_class
,
12024 show_memory_write_packet_size
,
12025 _("Show the maximum number of bytes per memory-write packet."),
12026 &remote_show_cmdlist
);
12027 add_cmd ("memory-read-packet-size", no_class
,
12028 show_memory_read_packet_size
,
12029 _("Show the maximum number of bytes per memory-read packet."),
12030 &remote_show_cmdlist
);
12032 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
12033 &remote_hw_watchpoint_limit
, _("\
12034 Set the maximum number of target hardware watchpoints."), _("\
12035 Show the maximum number of target hardware watchpoints."), _("\
12036 Specify a negative limit for unlimited."),
12037 NULL
, NULL
, /* FIXME: i18n: The maximum
12038 number of target hardware
12039 watchpoints is %s. */
12040 &remote_set_cmdlist
, &remote_show_cmdlist
);
12041 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
12042 &remote_hw_watchpoint_length_limit
, _("\
12043 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
12044 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
12045 Specify a negative limit for unlimited."),
12046 NULL
, NULL
, /* FIXME: i18n: The maximum
12047 length (in bytes) of a target
12048 hardware watchpoint is %s. */
12049 &remote_set_cmdlist
, &remote_show_cmdlist
);
12050 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
12051 &remote_hw_breakpoint_limit
, _("\
12052 Set the maximum number of target hardware breakpoints."), _("\
12053 Show the maximum number of target hardware breakpoints."), _("\
12054 Specify a negative limit for unlimited."),
12055 NULL
, NULL
, /* FIXME: i18n: The maximum
12056 number of target hardware
12057 breakpoints is %s. */
12058 &remote_set_cmdlist
, &remote_show_cmdlist
);
12060 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
12061 &remote_address_size
, _("\
12062 Set the maximum size of the address (in bits) in a memory packet."), _("\
12063 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
12065 NULL
, /* FIXME: i18n: */
12066 &setlist
, &showlist
);
12068 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
12069 "X", "binary-download", 1);
12071 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
12072 "vCont", "verbose-resume", 0);
12074 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
12075 "QPassSignals", "pass-signals", 0);
12077 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
12078 "QProgramSignals", "program-signals", 0);
12080 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
12081 "qSymbol", "symbol-lookup", 0);
12083 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
12084 "P", "set-register", 1);
12086 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
12087 "p", "fetch-register", 1);
12089 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
12090 "Z0", "software-breakpoint", 0);
12092 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
12093 "Z1", "hardware-breakpoint", 0);
12095 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
12096 "Z2", "write-watchpoint", 0);
12098 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
12099 "Z3", "read-watchpoint", 0);
12101 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
12102 "Z4", "access-watchpoint", 0);
12104 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
12105 "qXfer:auxv:read", "read-aux-vector", 0);
12107 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
12108 "qXfer:features:read", "target-features", 0);
12110 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
12111 "qXfer:libraries:read", "library-info", 0);
12113 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
12114 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
12116 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
12117 "qXfer:memory-map:read", "memory-map", 0);
12119 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
12120 "qXfer:spu:read", "read-spu-object", 0);
12122 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
12123 "qXfer:spu:write", "write-spu-object", 0);
12125 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
12126 "qXfer:osdata:read", "osdata", 0);
12128 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
12129 "qXfer:threads:read", "threads", 0);
12131 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
12132 "qXfer:siginfo:read", "read-siginfo-object", 0);
12134 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
12135 "qXfer:siginfo:write", "write-siginfo-object", 0);
12137 add_packet_config_cmd
12138 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
12139 "qXfer:traceframe-info:read", "traceframe-info", 0);
12141 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
12142 "qXfer:uib:read", "unwind-info-block", 0);
12144 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
12145 "qGetTLSAddr", "get-thread-local-storage-address",
12148 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
12149 "qGetTIBAddr", "get-thread-information-block-address",
12152 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
12153 "bc", "reverse-continue", 0);
12155 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
12156 "bs", "reverse-step", 0);
12158 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
12159 "qSupported", "supported-packets", 0);
12161 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
12162 "qSearch:memory", "search-memory", 0);
12164 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
12165 "qTStatus", "trace-status", 0);
12167 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
12168 "vFile:open", "hostio-open", 0);
12170 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
12171 "vFile:pread", "hostio-pread", 0);
12173 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
12174 "vFile:pwrite", "hostio-pwrite", 0);
12176 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
12177 "vFile:close", "hostio-close", 0);
12179 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
12180 "vFile:unlink", "hostio-unlink", 0);
12182 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
12183 "vFile:readlink", "hostio-readlink", 0);
12185 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
12186 "vAttach", "attach", 0);
12188 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
12191 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
12192 "QStartNoAckMode", "noack", 0);
12194 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
12195 "vKill", "kill", 0);
12197 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
12198 "qAttached", "query-attached", 0);
12200 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
12201 "ConditionalTracepoints",
12202 "conditional-tracepoints", 0);
12204 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
12205 "ConditionalBreakpoints",
12206 "conditional-breakpoints", 0);
12208 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
12209 "BreakpointCommands",
12210 "breakpoint-commands", 0);
12212 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
12213 "FastTracepoints", "fast-tracepoints", 0);
12215 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
12216 "TracepointSource", "TracepointSource", 0);
12218 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
12219 "QAllow", "allow", 0);
12221 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
12222 "StaticTracepoints", "static-tracepoints", 0);
12224 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
12225 "InstallInTrace", "install-in-trace", 0);
12227 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
12228 "qXfer:statictrace:read", "read-sdata-object", 0);
12230 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
12231 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
12233 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
12234 "QDisableRandomization", "disable-randomization", 0);
12236 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
12237 "QAgent", "agent", 0);
12239 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
12240 "QTBuffer:size", "trace-buffer-size", 0);
12242 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
12243 "Qbtrace:off", "disable-btrace", 0);
12245 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
12246 "Qbtrace:bts", "enable-btrace", 0);
12248 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
12249 "qXfer:btrace", "read-btrace", 0);
12251 /* Keep the old ``set remote Z-packet ...'' working. Each individual
12252 Z sub-packet has its own set and show commands, but users may
12253 have sets to this variable in their .gdbinit files (or in their
12255 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
12256 &remote_Z_packet_detect
, _("\
12257 Set use of remote protocol `Z' packets"), _("\
12258 Show use of remote protocol `Z' packets "), _("\
12259 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
12261 set_remote_protocol_Z_packet_cmd
,
12262 show_remote_protocol_Z_packet_cmd
,
12263 /* FIXME: i18n: Use of remote protocol
12264 `Z' packets is %s. */
12265 &remote_set_cmdlist
, &remote_show_cmdlist
);
12267 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
12268 Manipulate files on the remote system\n\
12269 Transfer files to and from the remote target system."),
12270 &remote_cmdlist
, "remote ",
12271 0 /* allow-unknown */, &cmdlist
);
12273 add_cmd ("put", class_files
, remote_put_command
,
12274 _("Copy a local file to the remote system."),
12277 add_cmd ("get", class_files
, remote_get_command
,
12278 _("Copy a remote file to the local system."),
12281 add_cmd ("delete", class_files
, remote_delete_command
,
12282 _("Delete a remote file."),
12285 remote_exec_file
= xstrdup ("");
12286 add_setshow_string_noescape_cmd ("exec-file", class_files
,
12287 &remote_exec_file
, _("\
12288 Set the remote pathname for \"run\""), _("\
12289 Show the remote pathname for \"run\""), NULL
, NULL
, NULL
,
12290 &remote_set_cmdlist
, &remote_show_cmdlist
);
12292 add_setshow_boolean_cmd ("range-stepping", class_run
,
12293 &use_range_stepping
, _("\
12294 Enable or disable range stepping."), _("\
12295 Show whether target-assisted range stepping is enabled."), _("\
12296 If on, and the target supports it, when stepping a source line, GDB\n\
12297 tells the target to step the corresponding range of addresses itself instead\n\
12298 of issuing multiple single-steps. This speeds up source level\n\
12299 stepping. If off, GDB always issues single-steps, even if range\n\
12300 stepping is supported by the target. The default is on."),
12301 set_range_stepping
,
12302 show_range_stepping
,
12306 /* Eventually initialize fileio. See fileio.c */
12307 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
12309 /* Take advantage of the fact that the LWP field is not used, to tag
12310 special ptids with it set to != 0. */
12311 magic_null_ptid
= ptid_build (42000, 1, -1);
12312 not_sent_ptid
= ptid_build (42000, 1, -2);
12313 any_thread_ptid
= ptid_build (42000, 1, 0);
12315 target_buf_size
= 2048;
12316 target_buf
= xmalloc (target_buf_size
);