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
, ULONGEST 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
, ULONGEST 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
, ULONGEST 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 volatile 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 (struct target_ops
*ops
,
8135 char *exec_file
, char *args
,
8136 char **env
, int from_tty
)
8140 struct remote_state
*rs
= get_remote_state ();
8142 /* If running asynchronously, register the target file descriptor
8143 with the event loop. */
8144 if (target_can_async_p ())
8145 target_async (inferior_event_handler
, 0);
8147 /* Disable address space randomization if requested (and supported). */
8148 if (extended_remote_supports_disable_randomization ())
8149 extended_remote_disable_randomization (disable_randomization
);
8151 /* Now restart the remote server. */
8152 run_worked
= extended_remote_run (args
) != -1;
8155 /* vRun was not supported. Fail if we need it to do what the
8157 if (remote_exec_file
[0])
8158 error (_("Remote target does not support \"set remote exec-file\""));
8160 error (_("Remote target does not support \"set args\" or run <ARGS>"));
8162 /* Fall back to "R". */
8163 extended_remote_restart ();
8166 if (!have_inferiors ())
8168 /* Clean up from the last time we ran, before we mark the target
8169 running again. This will mark breakpoints uninserted, and
8170 get_offsets may insert breakpoints. */
8171 init_thread_list ();
8172 init_wait_for_inferior ();
8175 /* vRun's success return is a stop reply. */
8176 stop_reply
= run_worked
? rs
->buf
: NULL
;
8177 add_current_inferior_and_thread (stop_reply
);
8179 /* Get updated offsets, if the stub uses qOffsets. */
8184 /* Given a location's target info BP_TGT and the packet buffer BUF, output
8185 the list of conditions (in agent expression bytecode format), if any, the
8186 target needs to evaluate. The output is placed into the packet buffer
8187 started from BUF and ended at BUF_END. */
8190 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
8191 struct bp_target_info
*bp_tgt
, char *buf
,
8194 struct agent_expr
*aexpr
= NULL
;
8197 char *buf_start
= buf
;
8199 if (VEC_empty (agent_expr_p
, bp_tgt
->conditions
))
8202 buf
+= strlen (buf
);
8203 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
8206 /* Send conditions to the target and free the vector. */
8208 VEC_iterate (agent_expr_p
, bp_tgt
->conditions
, ix
, aexpr
);
8211 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
8212 buf
+= strlen (buf
);
8213 for (i
= 0; i
< aexpr
->len
; ++i
)
8214 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
8221 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
8222 struct bp_target_info
*bp_tgt
, char *buf
)
8224 struct agent_expr
*aexpr
= NULL
;
8227 if (VEC_empty (agent_expr_p
, bp_tgt
->tcommands
))
8230 buf
+= strlen (buf
);
8232 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
8233 buf
+= strlen (buf
);
8235 /* Concatenate all the agent expressions that are commands into the
8238 VEC_iterate (agent_expr_p
, bp_tgt
->tcommands
, ix
, aexpr
);
8241 sprintf (buf
, "X%x,", aexpr
->len
);
8242 buf
+= strlen (buf
);
8243 for (i
= 0; i
< aexpr
->len
; ++i
)
8244 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
8249 /* Insert a breakpoint. On targets that have software breakpoint
8250 support, we ask the remote target to do the work; on targets
8251 which don't, we insert a traditional memory breakpoint. */
8254 remote_insert_breakpoint (struct target_ops
*ops
,
8255 struct gdbarch
*gdbarch
,
8256 struct bp_target_info
*bp_tgt
)
8258 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
8259 If it succeeds, then set the support to PACKET_ENABLE. If it
8260 fails, and the user has explicitly requested the Z support then
8261 report an error, otherwise, mark it disabled and go on. */
8263 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
8265 CORE_ADDR addr
= bp_tgt
->placed_address
;
8266 struct remote_state
*rs
;
8269 struct condition_list
*cond
= NULL
;
8271 /* Make sure the remote is pointing at the right process, if
8273 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8274 set_general_process ();
8276 gdbarch_remote_breakpoint_from_pc (gdbarch
, &addr
, &bpsize
);
8278 rs
= get_remote_state ();
8280 endbuf
= rs
->buf
+ get_remote_packet_size ();
8285 addr
= (ULONGEST
) remote_address_masked (addr
);
8286 p
+= hexnumstr (p
, addr
);
8287 xsnprintf (p
, endbuf
- p
, ",%d", bpsize
);
8289 if (remote_supports_cond_breakpoints ())
8290 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
8292 if (remote_can_run_breakpoint_commands ())
8293 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
8296 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8298 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
8303 bp_tgt
->placed_address
= addr
;
8304 bp_tgt
->placed_size
= bpsize
;
8306 case PACKET_UNKNOWN
:
8311 /* If this breakpoint has target-side commands but this stub doesn't
8312 support Z0 packets, throw error. */
8313 if (!VEC_empty (agent_expr_p
, bp_tgt
->tcommands
))
8314 throw_error (NOT_SUPPORTED_ERROR
, _("\
8315 Target doesn't support breakpoints that have target side commands."));
8317 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
8321 remote_remove_breakpoint (struct target_ops
*ops
,
8322 struct gdbarch
*gdbarch
,
8323 struct bp_target_info
*bp_tgt
)
8325 CORE_ADDR addr
= bp_tgt
->placed_address
;
8326 struct remote_state
*rs
= get_remote_state ();
8328 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
8331 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8333 /* Make sure the remote is pointing at the right process, if
8335 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8336 set_general_process ();
8342 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
8343 p
+= hexnumstr (p
, addr
);
8344 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->placed_size
);
8347 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8349 return (rs
->buf
[0] == 'E');
8352 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
8356 watchpoint_to_Z_packet (int type
)
8361 return Z_PACKET_WRITE_WP
;
8364 return Z_PACKET_READ_WP
;
8367 return Z_PACKET_ACCESS_WP
;
8370 internal_error (__FILE__
, __LINE__
,
8371 _("hw_bp_to_z: bad watchpoint type %d"), type
);
8376 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
8377 struct expression
*cond
)
8379 struct remote_state
*rs
= get_remote_state ();
8380 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8382 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
8384 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
8387 /* Make sure the remote is pointing at the right process, if
8389 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8390 set_general_process ();
8392 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
8393 p
= strchr (rs
->buf
, '\0');
8394 addr
= remote_address_masked (addr
);
8395 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8396 xsnprintf (p
, endbuf
- p
, ",%x", len
);
8399 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8401 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
8405 case PACKET_UNKNOWN
:
8410 internal_error (__FILE__
, __LINE__
,
8411 _("remote_insert_watchpoint: reached end of function"));
8415 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
8416 CORE_ADDR start
, int length
)
8418 CORE_ADDR diff
= remote_address_masked (addr
- start
);
8420 return diff
< length
;
8425 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
8426 struct expression
*cond
)
8428 struct remote_state
*rs
= get_remote_state ();
8429 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8431 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
8433 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
8436 /* Make sure the remote is pointing at the right process, if
8438 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8439 set_general_process ();
8441 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
8442 p
= strchr (rs
->buf
, '\0');
8443 addr
= remote_address_masked (addr
);
8444 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8445 xsnprintf (p
, endbuf
- p
, ",%x", len
);
8447 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8449 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
8452 case PACKET_UNKNOWN
:
8457 internal_error (__FILE__
, __LINE__
,
8458 _("remote_remove_watchpoint: reached end of function"));
8462 int remote_hw_watchpoint_limit
= -1;
8463 int remote_hw_watchpoint_length_limit
= -1;
8464 int remote_hw_breakpoint_limit
= -1;
8467 remote_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
8469 if (remote_hw_watchpoint_length_limit
== 0)
8471 else if (remote_hw_watchpoint_length_limit
< 0)
8473 else if (len
<= remote_hw_watchpoint_length_limit
)
8480 remote_check_watch_resources (int type
, int cnt
, int ot
)
8482 if (type
== bp_hardware_breakpoint
)
8484 if (remote_hw_breakpoint_limit
== 0)
8486 else if (remote_hw_breakpoint_limit
< 0)
8488 else if (cnt
<= remote_hw_breakpoint_limit
)
8493 if (remote_hw_watchpoint_limit
== 0)
8495 else if (remote_hw_watchpoint_limit
< 0)
8499 else if (cnt
<= remote_hw_watchpoint_limit
)
8506 remote_stopped_by_watchpoint (void)
8508 struct remote_state
*rs
= get_remote_state ();
8510 return rs
->remote_stopped_by_watchpoint_p
;
8514 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
8516 struct remote_state
*rs
= get_remote_state ();
8519 if (remote_stopped_by_watchpoint ())
8521 *addr_p
= rs
->remote_watch_data_address
;
8530 remote_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
8531 struct bp_target_info
*bp_tgt
)
8534 struct remote_state
*rs
;
8538 /* The length field should be set to the size of a breakpoint
8539 instruction, even though we aren't inserting one ourselves. */
8541 gdbarch_remote_breakpoint_from_pc
8542 (gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
8544 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
8547 /* Make sure the remote is pointing at the right process, if
8549 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8550 set_general_process ();
8552 rs
= get_remote_state ();
8554 endbuf
= rs
->buf
+ get_remote_packet_size ();
8560 addr
= remote_address_masked (bp_tgt
->placed_address
);
8561 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8562 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->placed_size
);
8564 if (remote_supports_cond_breakpoints ())
8565 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
8567 if (remote_can_run_breakpoint_commands ())
8568 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
8571 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8573 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
8576 if (rs
->buf
[1] == '.')
8578 message
= strchr (rs
->buf
+ 2, '.');
8580 error (_("Remote failure reply: %s"), message
+ 1);
8583 case PACKET_UNKNOWN
:
8588 internal_error (__FILE__
, __LINE__
,
8589 _("remote_insert_hw_breakpoint: reached end of function"));
8594 remote_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
8595 struct bp_target_info
*bp_tgt
)
8598 struct remote_state
*rs
= get_remote_state ();
8600 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
8602 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
8605 /* Make sure the remote is pointing at the right process, if
8607 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8608 set_general_process ();
8614 addr
= remote_address_masked (bp_tgt
->placed_address
);
8615 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8616 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->placed_size
);
8619 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8621 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
8624 case PACKET_UNKNOWN
:
8629 internal_error (__FILE__
, __LINE__
,
8630 _("remote_remove_hw_breakpoint: reached end of function"));
8633 /* Verify memory using the "qCRC:" request. */
8636 remote_verify_memory (struct target_ops
*ops
,
8637 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
8639 struct remote_state
*rs
= get_remote_state ();
8640 unsigned long host_crc
, target_crc
;
8643 /* Make sure the remote is pointing at the right process. */
8644 set_general_process ();
8646 /* FIXME: assumes lma can fit into long. */
8647 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
8648 (long) lma
, (long) size
);
8651 /* Be clever; compute the host_crc before waiting for target
8653 host_crc
= xcrc32 (data
, size
, 0xffffffff);
8655 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8656 if (rs
->buf
[0] == 'E')
8659 if (rs
->buf
[0] != 'C')
8660 error (_("remote target does not support this operation"));
8662 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
8663 target_crc
= target_crc
* 16 + fromhex (*tmp
);
8665 return (host_crc
== target_crc
);
8668 /* compare-sections command
8670 With no arguments, compares each loadable section in the exec bfd
8671 with the same memory range on the target, and reports mismatches.
8672 Useful for verifying the image on the target against the exec file. */
8675 compare_sections_command (char *args
, int from_tty
)
8678 struct cleanup
*old_chain
;
8680 const char *sectname
;
8688 error (_("command cannot be used without an exec file"));
8690 /* Make sure the remote is pointing at the right process. */
8691 set_general_process ();
8693 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
8695 if (!(s
->flags
& SEC_LOAD
))
8696 continue; /* Skip non-loadable section. */
8698 size
= bfd_get_section_size (s
);
8700 continue; /* Skip zero-length section. */
8702 sectname
= bfd_get_section_name (exec_bfd
, s
);
8703 if (args
&& strcmp (args
, sectname
) != 0)
8704 continue; /* Not the section selected by user. */
8706 matched
= 1; /* Do this section. */
8709 sectdata
= xmalloc (size
);
8710 old_chain
= make_cleanup (xfree
, sectdata
);
8711 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
8713 res
= target_verify_memory (sectdata
, lma
, size
);
8716 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
8717 paddress (target_gdbarch (), lma
),
8718 paddress (target_gdbarch (), lma
+ size
));
8720 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
8721 paddress (target_gdbarch (), lma
),
8722 paddress (target_gdbarch (), lma
+ size
));
8724 printf_filtered ("matched.\n");
8727 printf_filtered ("MIS-MATCHED!\n");
8731 do_cleanups (old_chain
);
8734 warning (_("One or more sections of the remote executable does not match\n\
8735 the loaded file\n"));
8736 if (args
&& !matched
)
8737 printf_filtered (_("No loaded section named '%s'.\n"), args
);
8740 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
8741 into remote target. The number of bytes written to the remote
8742 target is returned, or -1 for error. */
8745 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
8746 const char *annex
, const gdb_byte
*writebuf
,
8747 ULONGEST offset
, LONGEST len
,
8748 struct packet_config
*packet
)
8752 struct remote_state
*rs
= get_remote_state ();
8753 int max_size
= get_memory_write_packet_size ();
8755 if (packet
->support
== PACKET_DISABLE
)
8758 /* Insert header. */
8759 i
= snprintf (rs
->buf
, max_size
,
8760 "qXfer:%s:write:%s:%s:",
8761 object_name
, annex
? annex
: "",
8762 phex_nz (offset
, sizeof offset
));
8763 max_size
-= (i
+ 1);
8765 /* Escape as much data as fits into rs->buf. */
8766 buf_len
= remote_escape_output
8767 (writebuf
, len
, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
8769 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
8770 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
8771 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
8774 unpack_varlen_hex (rs
->buf
, &n
);
8778 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
8779 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
8780 number of bytes read is returned, or 0 for EOF, or -1 for error.
8781 The number of bytes read may be less than LEN without indicating an
8782 EOF. PACKET is checked and updated to indicate whether the remote
8783 target supports this object. */
8786 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
8788 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
8789 struct packet_config
*packet
)
8791 struct remote_state
*rs
= get_remote_state ();
8792 LONGEST i
, n
, packet_len
;
8794 if (packet
->support
== PACKET_DISABLE
)
8797 /* Check whether we've cached an end-of-object packet that matches
8799 if (rs
->finished_object
)
8801 if (strcmp (object_name
, rs
->finished_object
) == 0
8802 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
8803 && offset
== rs
->finished_offset
)
8806 /* Otherwise, we're now reading something different. Discard
8808 xfree (rs
->finished_object
);
8809 xfree (rs
->finished_annex
);
8810 rs
->finished_object
= NULL
;
8811 rs
->finished_annex
= NULL
;
8814 /* Request only enough to fit in a single packet. The actual data
8815 may not, since we don't know how much of it will need to be escaped;
8816 the target is free to respond with slightly less data. We subtract
8817 five to account for the response type and the protocol frame. */
8818 n
= min (get_remote_packet_size () - 5, len
);
8819 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
8820 object_name
, annex
? annex
: "",
8821 phex_nz (offset
, sizeof offset
),
8822 phex_nz (n
, sizeof n
));
8823 i
= putpkt (rs
->buf
);
8828 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
8829 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
8832 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
8833 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
8835 /* 'm' means there is (or at least might be) more data after this
8836 batch. That does not make sense unless there's at least one byte
8837 of data in this reply. */
8838 if (rs
->buf
[0] == 'm' && packet_len
== 1)
8839 error (_("Remote qXfer reply contained no data."));
8841 /* Got some data. */
8842 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
8843 packet_len
- 1, readbuf
, n
);
8845 /* 'l' is an EOF marker, possibly including a final block of data,
8846 or possibly empty. If we have the final block of a non-empty
8847 object, record this fact to bypass a subsequent partial read. */
8848 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
8850 rs
->finished_object
= xstrdup (object_name
);
8851 rs
->finished_annex
= xstrdup (annex
? annex
: "");
8852 rs
->finished_offset
= offset
+ i
;
8859 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
8860 const char *annex
, gdb_byte
*readbuf
,
8861 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
8863 struct remote_state
*rs
;
8868 set_remote_traceframe ();
8869 set_general_thread (inferior_ptid
);
8871 rs
= get_remote_state ();
8873 /* Handle memory using the standard memory routines. */
8874 if (object
== TARGET_OBJECT_MEMORY
)
8878 /* If the remote target is connected but not running, we should
8879 pass this request down to a lower stratum (e.g. the executable
8881 if (!target_has_execution
)
8884 if (writebuf
!= NULL
)
8885 xfered
= remote_write_bytes (offset
, writebuf
, len
);
8887 xfered
= remote_read_bytes (offset
, readbuf
, len
);
8892 /* Handle SPU memory using qxfer packets. */
8893 if (object
== TARGET_OBJECT_SPU
)
8896 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
8897 &remote_protocol_packets
8898 [PACKET_qXfer_spu_read
]);
8900 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
8901 &remote_protocol_packets
8902 [PACKET_qXfer_spu_write
]);
8905 /* Handle extra signal info using qxfer packets. */
8906 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
8909 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
8910 &remote_protocol_packets
8911 [PACKET_qXfer_siginfo_read
]);
8913 return remote_write_qxfer (ops
, "siginfo", annex
,
8914 writebuf
, offset
, len
,
8915 &remote_protocol_packets
8916 [PACKET_qXfer_siginfo_write
]);
8919 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
8922 return remote_read_qxfer (ops
, "statictrace", annex
,
8923 readbuf
, offset
, len
,
8924 &remote_protocol_packets
8925 [PACKET_qXfer_statictrace_read
]);
8930 /* Only handle flash writes. */
8931 if (writebuf
!= NULL
)
8937 case TARGET_OBJECT_FLASH
:
8938 return remote_flash_write (ops
, offset
, len
, writebuf
);
8945 /* Map pre-existing objects onto letters. DO NOT do this for new
8946 objects!!! Instead specify new query packets. */
8949 case TARGET_OBJECT_AVR
:
8953 case TARGET_OBJECT_AUXV
:
8954 gdb_assert (annex
== NULL
);
8955 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
8956 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
8958 case TARGET_OBJECT_AVAILABLE_FEATURES
:
8959 return remote_read_qxfer
8960 (ops
, "features", annex
, readbuf
, offset
, len
,
8961 &remote_protocol_packets
[PACKET_qXfer_features
]);
8963 case TARGET_OBJECT_LIBRARIES
:
8964 return remote_read_qxfer
8965 (ops
, "libraries", annex
, readbuf
, offset
, len
,
8966 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
8968 case TARGET_OBJECT_LIBRARIES_SVR4
:
8969 return remote_read_qxfer
8970 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
,
8971 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
8973 case TARGET_OBJECT_MEMORY_MAP
:
8974 gdb_assert (annex
== NULL
);
8975 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
8976 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
8978 case TARGET_OBJECT_OSDATA
:
8979 /* Should only get here if we're connected. */
8980 gdb_assert (rs
->remote_desc
);
8981 return remote_read_qxfer
8982 (ops
, "osdata", annex
, readbuf
, offset
, len
,
8983 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
8985 case TARGET_OBJECT_THREADS
:
8986 gdb_assert (annex
== NULL
);
8987 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
8988 &remote_protocol_packets
[PACKET_qXfer_threads
]);
8990 case TARGET_OBJECT_TRACEFRAME_INFO
:
8991 gdb_assert (annex
== NULL
);
8992 return remote_read_qxfer
8993 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
,
8994 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
8996 case TARGET_OBJECT_FDPIC
:
8997 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
8998 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
9000 case TARGET_OBJECT_OPENVMS_UIB
:
9001 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
9002 &remote_protocol_packets
[PACKET_qXfer_uib
]);
9004 case TARGET_OBJECT_BTRACE
:
9005 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
9006 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
9012 /* Note: a zero OFFSET and LEN can be used to query the minimum
9014 if (offset
== 0 && len
== 0)
9015 return (get_remote_packet_size ());
9016 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
9017 large enough let the caller deal with it. */
9018 if (len
< get_remote_packet_size ())
9020 len
= get_remote_packet_size ();
9022 /* Except for querying the minimum buffer size, target must be open. */
9023 if (!rs
->remote_desc
)
9024 error (_("remote query is only available after target open"));
9026 gdb_assert (annex
!= NULL
);
9027 gdb_assert (readbuf
!= NULL
);
9033 /* We used one buffer char for the remote protocol q command and
9034 another for the query type. As the remote protocol encapsulation
9035 uses 4 chars plus one extra in case we are debugging
9036 (remote_debug), we have PBUFZIZ - 7 left to pack the query
9039 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
9041 /* Bad caller may have sent forbidden characters. */
9042 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
9047 gdb_assert (annex
[i
] == '\0');
9049 i
= putpkt (rs
->buf
);
9053 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9054 strcpy ((char *) readbuf
, rs
->buf
);
9056 return strlen ((char *) readbuf
);
9060 remote_search_memory (struct target_ops
* ops
,
9061 CORE_ADDR start_addr
, ULONGEST search_space_len
,
9062 const gdb_byte
*pattern
, ULONGEST pattern_len
,
9063 CORE_ADDR
*found_addrp
)
9065 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9066 struct remote_state
*rs
= get_remote_state ();
9067 int max_size
= get_memory_write_packet_size ();
9068 struct packet_config
*packet
=
9069 &remote_protocol_packets
[PACKET_qSearch_memory
];
9070 /* Number of packet bytes used to encode the pattern;
9071 this could be more than PATTERN_LEN due to escape characters. */
9072 int escaped_pattern_len
;
9073 /* Amount of pattern that was encodable in the packet. */
9074 int used_pattern_len
;
9077 ULONGEST found_addr
;
9079 /* Don't go to the target if we don't have to.
9080 This is done before checking packet->support to avoid the possibility that
9081 a success for this edge case means the facility works in general. */
9082 if (pattern_len
> search_space_len
)
9084 if (pattern_len
== 0)
9086 *found_addrp
= start_addr
;
9090 /* If we already know the packet isn't supported, fall back to the simple
9091 way of searching memory. */
9093 if (packet
->support
== PACKET_DISABLE
)
9095 /* Target doesn't provided special support, fall back and use the
9096 standard support (copy memory and do the search here). */
9097 return simple_search_memory (ops
, start_addr
, search_space_len
,
9098 pattern
, pattern_len
, found_addrp
);
9101 /* Make sure the remote is pointing at the right process. */
9102 set_general_process ();
9104 /* Insert header. */
9105 i
= snprintf (rs
->buf
, max_size
,
9106 "qSearch:memory:%s;%s;",
9107 phex_nz (start_addr
, addr_size
),
9108 phex_nz (search_space_len
, sizeof (search_space_len
)));
9109 max_size
-= (i
+ 1);
9111 /* Escape as much data as fits into rs->buf. */
9112 escaped_pattern_len
=
9113 remote_escape_output (pattern
, pattern_len
, (gdb_byte
*) rs
->buf
+ i
,
9114 &used_pattern_len
, max_size
);
9116 /* Bail if the pattern is too large. */
9117 if (used_pattern_len
!= pattern_len
)
9118 error (_("Pattern is too large to transmit to remote target."));
9120 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
9121 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
9122 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
9124 /* The request may not have worked because the command is not
9125 supported. If so, fall back to the simple way. */
9126 if (packet
->support
== PACKET_DISABLE
)
9128 return simple_search_memory (ops
, start_addr
, search_space_len
,
9129 pattern
, pattern_len
, found_addrp
);
9134 if (rs
->buf
[0] == '0')
9136 else if (rs
->buf
[0] == '1')
9139 if (rs
->buf
[1] != ',')
9140 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
9141 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
9142 *found_addrp
= found_addr
;
9145 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
9151 remote_rcmd (char *command
,
9152 struct ui_file
*outbuf
)
9154 struct remote_state
*rs
= get_remote_state ();
9157 if (!rs
->remote_desc
)
9158 error (_("remote rcmd is only available after target open"));
9160 /* Send a NULL command across as an empty command. */
9161 if (command
== NULL
)
9164 /* The query prefix. */
9165 strcpy (rs
->buf
, "qRcmd,");
9166 p
= strchr (rs
->buf
, '\0');
9168 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
9169 > get_remote_packet_size ())
9170 error (_("\"monitor\" command ``%s'' is too long."), command
);
9172 /* Encode the actual command. */
9173 bin2hex ((gdb_byte
*) command
, p
, 0);
9175 if (putpkt (rs
->buf
) < 0)
9176 error (_("Communication problem with target."));
9178 /* get/display the response */
9183 /* XXX - see also remote_get_noisy_reply(). */
9184 QUIT
; /* Allow user to bail out with ^C. */
9186 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
9188 /* Timeout. Continue to (try to) read responses.
9189 This is better than stopping with an error, assuming the stub
9190 is still executing the (long) monitor command.
9191 If needed, the user can interrupt gdb using C-c, obtaining
9192 an effect similar to stop on timeout. */
9197 error (_("Target does not support this command."));
9198 if (buf
[0] == 'O' && buf
[1] != 'K')
9200 remote_console_output (buf
+ 1); /* 'O' message from stub. */
9203 if (strcmp (buf
, "OK") == 0)
9205 if (strlen (buf
) == 3 && buf
[0] == 'E'
9206 && isdigit (buf
[1]) && isdigit (buf
[2]))
9208 error (_("Protocol error with Rcmd"));
9210 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
9212 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
9214 fputc_unfiltered (c
, outbuf
);
9220 static VEC(mem_region_s
) *
9221 remote_memory_map (struct target_ops
*ops
)
9223 VEC(mem_region_s
) *result
= NULL
;
9224 char *text
= target_read_stralloc (¤t_target
,
9225 TARGET_OBJECT_MEMORY_MAP
, NULL
);
9229 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
9231 result
= parse_memory_map (text
);
9232 do_cleanups (back_to
);
9239 packet_command (char *args
, int from_tty
)
9241 struct remote_state
*rs
= get_remote_state ();
9243 if (!rs
->remote_desc
)
9244 error (_("command can only be used with remote target"));
9247 error (_("remote-packet command requires packet text as argument"));
9249 puts_filtered ("sending: ");
9250 print_packet (args
);
9251 puts_filtered ("\n");
9254 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9255 puts_filtered ("received: ");
9256 print_packet (rs
->buf
);
9257 puts_filtered ("\n");
9261 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
9263 static void display_thread_info (struct gdb_ext_thread_info
*info
);
9265 static void threadset_test_cmd (char *cmd
, int tty
);
9267 static void threadalive_test (char *cmd
, int tty
);
9269 static void threadlist_test_cmd (char *cmd
, int tty
);
9271 int get_and_display_threadinfo (threadref
*ref
);
9273 static void threadinfo_test_cmd (char *cmd
, int tty
);
9275 static int thread_display_step (threadref
*ref
, void *context
);
9277 static void threadlist_update_test_cmd (char *cmd
, int tty
);
9279 static void init_remote_threadtests (void);
9281 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
9284 threadset_test_cmd (char *cmd
, int tty
)
9286 int sample_thread
= SAMPLE_THREAD
;
9288 printf_filtered (_("Remote threadset test\n"));
9289 set_general_thread (sample_thread
);
9294 threadalive_test (char *cmd
, int tty
)
9296 int sample_thread
= SAMPLE_THREAD
;
9297 int pid
= ptid_get_pid (inferior_ptid
);
9298 ptid_t ptid
= ptid_build (pid
, 0, sample_thread
);
9300 if (remote_thread_alive (ptid
))
9301 printf_filtered ("PASS: Thread alive test\n");
9303 printf_filtered ("FAIL: Thread alive test\n");
9306 void output_threadid (char *title
, threadref
*ref
);
9309 output_threadid (char *title
, threadref
*ref
)
9313 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
9315 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
9319 threadlist_test_cmd (char *cmd
, int tty
)
9322 threadref nextthread
;
9323 int done
, result_count
;
9324 threadref threadlist
[3];
9326 printf_filtered ("Remote Threadlist test\n");
9327 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
9328 &result_count
, &threadlist
[0]))
9329 printf_filtered ("FAIL: threadlist test\n");
9332 threadref
*scan
= threadlist
;
9333 threadref
*limit
= scan
+ result_count
;
9335 while (scan
< limit
)
9336 output_threadid (" thread ", scan
++);
9341 display_thread_info (struct gdb_ext_thread_info
*info
)
9343 output_threadid ("Threadid: ", &info
->threadid
);
9344 printf_filtered ("Name: %s\n ", info
->shortname
);
9345 printf_filtered ("State: %s\n", info
->display
);
9346 printf_filtered ("other: %s\n\n", info
->more_display
);
9350 get_and_display_threadinfo (threadref
*ref
)
9354 struct gdb_ext_thread_info threadinfo
;
9356 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
9357 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
9358 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
9359 display_thread_info (&threadinfo
);
9364 threadinfo_test_cmd (char *cmd
, int tty
)
9366 int athread
= SAMPLE_THREAD
;
9370 int_to_threadref (&thread
, athread
);
9371 printf_filtered ("Remote Threadinfo test\n");
9372 if (!get_and_display_threadinfo (&thread
))
9373 printf_filtered ("FAIL cannot get thread info\n");
9377 thread_display_step (threadref
*ref
, void *context
)
9379 /* output_threadid(" threadstep ",ref); *//* simple test */
9380 return get_and_display_threadinfo (ref
);
9384 threadlist_update_test_cmd (char *cmd
, int tty
)
9386 printf_filtered ("Remote Threadlist update test\n");
9387 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
9391 init_remote_threadtests (void)
9393 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
9394 _("Fetch and print the remote list of "
9395 "thread identifiers, one pkt only"));
9396 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
9397 _("Fetch and display info about one thread"));
9398 add_com ("tset", class_obscure
, threadset_test_cmd
,
9399 _("Test setting to a different thread"));
9400 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
9401 _("Iterate through updating all remote thread info"));
9402 add_com ("talive", class_obscure
, threadalive_test
,
9403 _(" Remote thread alive test "));
9408 /* Convert a thread ID to a string. Returns the string in a static
9412 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
9414 static char buf
[64];
9415 struct remote_state
*rs
= get_remote_state ();
9417 if (ptid_equal (ptid
, null_ptid
))
9418 return normal_pid_to_str (ptid
);
9419 else if (ptid_is_pid (ptid
))
9421 /* Printing an inferior target id. */
9423 /* When multi-process extensions are off, there's no way in the
9424 remote protocol to know the remote process id, if there's any
9425 at all. There's one exception --- when we're connected with
9426 target extended-remote, and we manually attached to a process
9427 with "attach PID". We don't record anywhere a flag that
9428 allows us to distinguish that case from the case of
9429 connecting with extended-remote and the stub already being
9430 attached to a process, and reporting yes to qAttached, hence
9431 no smart special casing here. */
9432 if (!remote_multi_process_p (rs
))
9434 xsnprintf (buf
, sizeof buf
, "Remote target");
9438 return normal_pid_to_str (ptid
);
9442 if (ptid_equal (magic_null_ptid
, ptid
))
9443 xsnprintf (buf
, sizeof buf
, "Thread <main>");
9444 else if (rs
->extended
&& remote_multi_process_p (rs
))
9445 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
9446 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
9448 xsnprintf (buf
, sizeof buf
, "Thread %ld",
9449 ptid_get_tid (ptid
));
9454 /* Get the address of the thread local variable in OBJFILE which is
9455 stored at OFFSET within the thread local storage for thread PTID. */
9458 remote_get_thread_local_address (struct target_ops
*ops
,
9459 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
9461 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
9463 struct remote_state
*rs
= get_remote_state ();
9465 char *endp
= rs
->buf
+ get_remote_packet_size ();
9466 enum packet_result result
;
9468 strcpy (p
, "qGetTLSAddr:");
9470 p
= write_ptid (p
, endp
, ptid
);
9472 p
+= hexnumstr (p
, offset
);
9474 p
+= hexnumstr (p
, lm
);
9478 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9479 result
= packet_ok (rs
->buf
,
9480 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
9481 if (result
== PACKET_OK
)
9485 unpack_varlen_hex (rs
->buf
, &result
);
9488 else if (result
== PACKET_UNKNOWN
)
9489 throw_error (TLS_GENERIC_ERROR
,
9490 _("Remote target doesn't support qGetTLSAddr packet"));
9492 throw_error (TLS_GENERIC_ERROR
,
9493 _("Remote target failed to process qGetTLSAddr request"));
9496 throw_error (TLS_GENERIC_ERROR
,
9497 _("TLS not supported or disabled on this target"));
9502 /* Provide thread local base, i.e. Thread Information Block address.
9503 Returns 1 if ptid is found and thread_local_base is non zero. */
9506 remote_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
9508 if (remote_protocol_packets
[PACKET_qGetTIBAddr
].support
!= PACKET_DISABLE
)
9510 struct remote_state
*rs
= get_remote_state ();
9512 char *endp
= rs
->buf
+ get_remote_packet_size ();
9513 enum packet_result result
;
9515 strcpy (p
, "qGetTIBAddr:");
9517 p
= write_ptid (p
, endp
, ptid
);
9521 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9522 result
= packet_ok (rs
->buf
,
9523 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
9524 if (result
== PACKET_OK
)
9528 unpack_varlen_hex (rs
->buf
, &result
);
9530 *addr
= (CORE_ADDR
) result
;
9533 else if (result
== PACKET_UNKNOWN
)
9534 error (_("Remote target doesn't support qGetTIBAddr packet"));
9536 error (_("Remote target failed to process qGetTIBAddr request"));
9539 error (_("qGetTIBAddr not supported or disabled on this target"));
9544 /* Support for inferring a target description based on the current
9545 architecture and the size of a 'g' packet. While the 'g' packet
9546 can have any size (since optional registers can be left off the
9547 end), some sizes are easily recognizable given knowledge of the
9548 approximate architecture. */
9550 struct remote_g_packet_guess
9553 const struct target_desc
*tdesc
;
9555 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
9556 DEF_VEC_O(remote_g_packet_guess_s
);
9558 struct remote_g_packet_data
9560 VEC(remote_g_packet_guess_s
) *guesses
;
9563 static struct gdbarch_data
*remote_g_packet_data_handle
;
9566 remote_g_packet_data_init (struct obstack
*obstack
)
9568 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
9572 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
9573 const struct target_desc
*tdesc
)
9575 struct remote_g_packet_data
*data
9576 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
9577 struct remote_g_packet_guess new_guess
, *guess
;
9580 gdb_assert (tdesc
!= NULL
);
9583 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
9585 if (guess
->bytes
== bytes
)
9586 internal_error (__FILE__
, __LINE__
,
9587 _("Duplicate g packet description added for size %d"),
9590 new_guess
.bytes
= bytes
;
9591 new_guess
.tdesc
= tdesc
;
9592 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
9595 /* Return 1 if remote_read_description would do anything on this target
9596 and architecture, 0 otherwise. */
9599 remote_read_description_p (struct target_ops
*target
)
9601 struct remote_g_packet_data
*data
9602 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
);
9604 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
9610 static const struct target_desc
*
9611 remote_read_description (struct target_ops
*target
)
9613 struct remote_g_packet_data
*data
9614 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
);
9616 /* Do not try this during initial connection, when we do not know
9617 whether there is a running but stopped thread. */
9618 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
9621 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
9623 struct remote_g_packet_guess
*guess
;
9625 int bytes
= send_g_packet ();
9628 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
9630 if (guess
->bytes
== bytes
)
9631 return guess
->tdesc
;
9633 /* We discard the g packet. A minor optimization would be to
9634 hold on to it, and fill the register cache once we have selected
9635 an architecture, but it's too tricky to do safely. */
9641 /* Remote file transfer support. This is host-initiated I/O, not
9642 target-initiated; for target-initiated, see remote-fileio.c. */
9644 /* If *LEFT is at least the length of STRING, copy STRING to
9645 *BUFFER, update *BUFFER to point to the new end of the buffer, and
9646 decrease *LEFT. Otherwise raise an error. */
9649 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
9651 int len
= strlen (string
);
9654 error (_("Packet too long for target."));
9656 memcpy (*buffer
, string
, len
);
9660 /* NUL-terminate the buffer as a convenience, if there is
9666 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
9667 *BUFFER, update *BUFFER to point to the new end of the buffer, and
9668 decrease *LEFT. Otherwise raise an error. */
9671 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
9674 if (2 * len
> *left
)
9675 error (_("Packet too long for target."));
9677 bin2hex (bytes
, *buffer
, len
);
9681 /* NUL-terminate the buffer as a convenience, if there is
9687 /* If *LEFT is large enough, convert VALUE to hex and add it to
9688 *BUFFER, update *BUFFER to point to the new end of the buffer, and
9689 decrease *LEFT. Otherwise raise an error. */
9692 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
9694 int len
= hexnumlen (value
);
9697 error (_("Packet too long for target."));
9699 hexnumstr (*buffer
, value
);
9703 /* NUL-terminate the buffer as a convenience, if there is
9709 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
9710 value, *REMOTE_ERRNO to the remote error number or zero if none
9711 was included, and *ATTACHMENT to point to the start of the annex
9712 if any. The length of the packet isn't needed here; there may
9713 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
9715 Return 0 if the packet could be parsed, -1 if it could not. If
9716 -1 is returned, the other variables may not be initialized. */
9719 remote_hostio_parse_result (char *buffer
, int *retcode
,
9720 int *remote_errno
, char **attachment
)
9727 if (buffer
[0] != 'F')
9731 *retcode
= strtol (&buffer
[1], &p
, 16);
9732 if (errno
!= 0 || p
== &buffer
[1])
9735 /* Check for ",errno". */
9739 *remote_errno
= strtol (p
+ 1, &p2
, 16);
9740 if (errno
!= 0 || p
+ 1 == p2
)
9745 /* Check for ";attachment". If there is no attachment, the
9746 packet should end here. */
9749 *attachment
= p
+ 1;
9752 else if (*p
== '\0')
9758 /* Send a prepared I/O packet to the target and read its response.
9759 The prepared packet is in the global RS->BUF before this function
9760 is called, and the answer is there when we return.
9762 COMMAND_BYTES is the length of the request to send, which may include
9763 binary data. WHICH_PACKET is the packet configuration to check
9764 before attempting a packet. If an error occurs, *REMOTE_ERRNO
9765 is set to the error number and -1 is returned. Otherwise the value
9766 returned by the function is returned.
9768 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
9769 attachment is expected; an error will be reported if there's a
9770 mismatch. If one is found, *ATTACHMENT will be set to point into
9771 the packet buffer and *ATTACHMENT_LEN will be set to the
9772 attachment's length. */
9775 remote_hostio_send_command (int command_bytes
, int which_packet
,
9776 int *remote_errno
, char **attachment
,
9777 int *attachment_len
)
9779 struct remote_state
*rs
= get_remote_state ();
9780 int ret
, bytes_read
;
9781 char *attachment_tmp
;
9783 if (!rs
->remote_desc
9784 || remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
9786 *remote_errno
= FILEIO_ENOSYS
;
9790 putpkt_binary (rs
->buf
, command_bytes
);
9791 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
9793 /* If it timed out, something is wrong. Don't try to parse the
9797 *remote_errno
= FILEIO_EINVAL
;
9801 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
9804 *remote_errno
= FILEIO_EINVAL
;
9806 case PACKET_UNKNOWN
:
9807 *remote_errno
= FILEIO_ENOSYS
;
9813 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
9816 *remote_errno
= FILEIO_EINVAL
;
9820 /* Make sure we saw an attachment if and only if we expected one. */
9821 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
9822 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
9824 *remote_errno
= FILEIO_EINVAL
;
9828 /* If an attachment was found, it must point into the packet buffer;
9829 work out how many bytes there were. */
9830 if (attachment_tmp
!= NULL
)
9832 *attachment
= attachment_tmp
;
9833 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
9839 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
9840 remote file descriptor, or -1 if an error occurs (and set
9844 remote_hostio_open (const char *filename
, int flags
, int mode
,
9847 struct remote_state
*rs
= get_remote_state ();
9849 int left
= get_remote_packet_size () - 1;
9851 remote_buffer_add_string (&p
, &left
, "vFile:open:");
9853 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
9855 remote_buffer_add_string (&p
, &left
, ",");
9857 remote_buffer_add_int (&p
, &left
, flags
);
9858 remote_buffer_add_string (&p
, &left
, ",");
9860 remote_buffer_add_int (&p
, &left
, mode
);
9862 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
9863 remote_errno
, NULL
, NULL
);
9866 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
9867 Return the number of bytes written, or -1 if an error occurs (and
9868 set *REMOTE_ERRNO). */
9871 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
9872 ULONGEST offset
, int *remote_errno
)
9874 struct remote_state
*rs
= get_remote_state ();
9876 int left
= get_remote_packet_size ();
9879 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
9881 remote_buffer_add_int (&p
, &left
, fd
);
9882 remote_buffer_add_string (&p
, &left
, ",");
9884 remote_buffer_add_int (&p
, &left
, offset
);
9885 remote_buffer_add_string (&p
, &left
, ",");
9887 p
+= remote_escape_output (write_buf
, len
, (gdb_byte
*) p
, &out_len
,
9888 get_remote_packet_size () - (p
- rs
->buf
));
9890 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
9891 remote_errno
, NULL
, NULL
);
9894 /* Read up to LEN bytes FD on the remote target into READ_BUF
9895 Return the number of bytes read, or -1 if an error occurs (and
9896 set *REMOTE_ERRNO). */
9899 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
9900 ULONGEST offset
, int *remote_errno
)
9902 struct remote_state
*rs
= get_remote_state ();
9905 int left
= get_remote_packet_size ();
9906 int ret
, attachment_len
;
9909 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
9911 remote_buffer_add_int (&p
, &left
, fd
);
9912 remote_buffer_add_string (&p
, &left
, ",");
9914 remote_buffer_add_int (&p
, &left
, len
);
9915 remote_buffer_add_string (&p
, &left
, ",");
9917 remote_buffer_add_int (&p
, &left
, offset
);
9919 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
9920 remote_errno
, &attachment
,
9926 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
9928 if (read_len
!= ret
)
9929 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
9934 /* Close FD on the remote target. Return 0, or -1 if an error occurs
9935 (and set *REMOTE_ERRNO). */
9938 remote_hostio_close (int fd
, int *remote_errno
)
9940 struct remote_state
*rs
= get_remote_state ();
9942 int left
= get_remote_packet_size () - 1;
9944 remote_buffer_add_string (&p
, &left
, "vFile:close:");
9946 remote_buffer_add_int (&p
, &left
, fd
);
9948 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
9949 remote_errno
, NULL
, NULL
);
9952 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
9953 occurs (and set *REMOTE_ERRNO). */
9956 remote_hostio_unlink (const char *filename
, int *remote_errno
)
9958 struct remote_state
*rs
= get_remote_state ();
9960 int left
= get_remote_packet_size () - 1;
9962 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
9964 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
9967 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
9968 remote_errno
, NULL
, NULL
);
9971 /* Read value of symbolic link FILENAME on the remote target. Return
9972 a null-terminated string allocated via xmalloc, or NULL if an error
9973 occurs (and set *REMOTE_ERRNO). */
9976 remote_hostio_readlink (const char *filename
, int *remote_errno
)
9978 struct remote_state
*rs
= get_remote_state ();
9981 int left
= get_remote_packet_size ();
9982 int len
, attachment_len
;
9986 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
9988 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
9991 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
9992 remote_errno
, &attachment
,
9998 ret
= xmalloc (len
+ 1);
10000 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
10001 (gdb_byte
*) ret
, len
);
10002 if (read_len
!= len
)
10003 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
10010 remote_fileio_errno_to_host (int errnum
)
10016 case FILEIO_ENOENT
:
10024 case FILEIO_EACCES
:
10026 case FILEIO_EFAULT
:
10030 case FILEIO_EEXIST
:
10032 case FILEIO_ENODEV
:
10034 case FILEIO_ENOTDIR
:
10036 case FILEIO_EISDIR
:
10038 case FILEIO_EINVAL
:
10040 case FILEIO_ENFILE
:
10042 case FILEIO_EMFILE
:
10046 case FILEIO_ENOSPC
:
10048 case FILEIO_ESPIPE
:
10052 case FILEIO_ENOSYS
:
10054 case FILEIO_ENAMETOOLONG
:
10055 return ENAMETOOLONG
;
10061 remote_hostio_error (int errnum
)
10063 int host_error
= remote_fileio_errno_to_host (errnum
);
10065 if (host_error
== -1)
10066 error (_("Unknown remote I/O error %d"), errnum
);
10068 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
10072 remote_hostio_close_cleanup (void *opaque
)
10074 int fd
= *(int *) opaque
;
10077 remote_hostio_close (fd
, &remote_errno
);
10082 remote_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
10084 const char *filename
= bfd_get_filename (abfd
);
10085 int fd
, remote_errno
;
10088 gdb_assert (remote_filename_p (filename
));
10090 fd
= remote_hostio_open (filename
+ 7, FILEIO_O_RDONLY
, 0, &remote_errno
);
10093 errno
= remote_fileio_errno_to_host (remote_errno
);
10094 bfd_set_error (bfd_error_system_call
);
10098 stream
= xmalloc (sizeof (int));
10104 remote_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
10106 int fd
= *(int *)stream
;
10111 /* Ignore errors on close; these may happen if the remote
10112 connection was already torn down. */
10113 remote_hostio_close (fd
, &remote_errno
);
10115 /* Zero means success. */
10120 remote_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
10121 file_ptr nbytes
, file_ptr offset
)
10123 int fd
= *(int *)stream
;
10125 file_ptr pos
, bytes
;
10128 while (nbytes
> pos
)
10130 bytes
= remote_hostio_pread (fd
, (gdb_byte
*) buf
+ pos
, nbytes
- pos
,
10131 offset
+ pos
, &remote_errno
);
10133 /* Success, but no bytes, means end-of-file. */
10137 errno
= remote_fileio_errno_to_host (remote_errno
);
10138 bfd_set_error (bfd_error_system_call
);
10149 remote_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
10151 /* FIXME: We should probably implement remote_hostio_stat. */
10152 sb
->st_size
= INT_MAX
;
10157 remote_filename_p (const char *filename
)
10159 return strncmp (filename
,
10160 REMOTE_SYSROOT_PREFIX
,
10161 sizeof (REMOTE_SYSROOT_PREFIX
) - 1) == 0;
10165 remote_bfd_open (const char *remote_file
, const char *target
)
10167 bfd
*abfd
= gdb_bfd_openr_iovec (remote_file
, target
,
10168 remote_bfd_iovec_open
, NULL
,
10169 remote_bfd_iovec_pread
,
10170 remote_bfd_iovec_close
,
10171 remote_bfd_iovec_stat
);
10177 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
10179 struct cleanup
*back_to
, *close_cleanup
;
10180 int retcode
, fd
, remote_errno
, bytes
, io_size
;
10183 int bytes_in_buffer
;
10186 struct remote_state
*rs
= get_remote_state ();
10188 if (!rs
->remote_desc
)
10189 error (_("command can only be used with remote target"));
10191 file
= gdb_fopen_cloexec (local_file
, "rb");
10193 perror_with_name (local_file
);
10194 back_to
= make_cleanup_fclose (file
);
10196 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
10198 0700, &remote_errno
);
10200 remote_hostio_error (remote_errno
);
10202 /* Send up to this many bytes at once. They won't all fit in the
10203 remote packet limit, so we'll transfer slightly fewer. */
10204 io_size
= get_remote_packet_size ();
10205 buffer
= xmalloc (io_size
);
10206 make_cleanup (xfree
, buffer
);
10208 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
10210 bytes_in_buffer
= 0;
10213 while (bytes_in_buffer
|| !saw_eof
)
10217 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
10218 io_size
- bytes_in_buffer
,
10223 error (_("Error reading %s."), local_file
);
10226 /* EOF. Unless there is something still in the
10227 buffer from the last iteration, we are done. */
10229 if (bytes_in_buffer
== 0)
10237 bytes
+= bytes_in_buffer
;
10238 bytes_in_buffer
= 0;
10240 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
,
10241 offset
, &remote_errno
);
10244 remote_hostio_error (remote_errno
);
10245 else if (retcode
== 0)
10246 error (_("Remote write of %d bytes returned 0!"), bytes
);
10247 else if (retcode
< bytes
)
10249 /* Short write. Save the rest of the read data for the next
10251 bytes_in_buffer
= bytes
- retcode
;
10252 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
10258 discard_cleanups (close_cleanup
);
10259 if (remote_hostio_close (fd
, &remote_errno
))
10260 remote_hostio_error (remote_errno
);
10263 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
10264 do_cleanups (back_to
);
10268 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
10270 struct cleanup
*back_to
, *close_cleanup
;
10271 int fd
, remote_errno
, bytes
, io_size
;
10275 struct remote_state
*rs
= get_remote_state ();
10277 if (!rs
->remote_desc
)
10278 error (_("command can only be used with remote target"));
10280 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
10282 remote_hostio_error (remote_errno
);
10284 file
= gdb_fopen_cloexec (local_file
, "wb");
10286 perror_with_name (local_file
);
10287 back_to
= make_cleanup_fclose (file
);
10289 /* Send up to this many bytes at once. They won't all fit in the
10290 remote packet limit, so we'll transfer slightly fewer. */
10291 io_size
= get_remote_packet_size ();
10292 buffer
= xmalloc (io_size
);
10293 make_cleanup (xfree
, buffer
);
10295 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
10300 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
10302 /* Success, but no bytes, means end-of-file. */
10305 remote_hostio_error (remote_errno
);
10309 bytes
= fwrite (buffer
, 1, bytes
, file
);
10311 perror_with_name (local_file
);
10314 discard_cleanups (close_cleanup
);
10315 if (remote_hostio_close (fd
, &remote_errno
))
10316 remote_hostio_error (remote_errno
);
10319 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
10320 do_cleanups (back_to
);
10324 remote_file_delete (const char *remote_file
, int from_tty
)
10326 int retcode
, remote_errno
;
10327 struct remote_state
*rs
= get_remote_state ();
10329 if (!rs
->remote_desc
)
10330 error (_("command can only be used with remote target"));
10332 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
10334 remote_hostio_error (remote_errno
);
10337 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
10341 remote_put_command (char *args
, int from_tty
)
10343 struct cleanup
*back_to
;
10347 error_no_arg (_("file to put"));
10349 argv
= gdb_buildargv (args
);
10350 back_to
= make_cleanup_freeargv (argv
);
10351 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
10352 error (_("Invalid parameters to remote put"));
10354 remote_file_put (argv
[0], argv
[1], from_tty
);
10356 do_cleanups (back_to
);
10360 remote_get_command (char *args
, int from_tty
)
10362 struct cleanup
*back_to
;
10366 error_no_arg (_("file to get"));
10368 argv
= gdb_buildargv (args
);
10369 back_to
= make_cleanup_freeargv (argv
);
10370 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
10371 error (_("Invalid parameters to remote get"));
10373 remote_file_get (argv
[0], argv
[1], from_tty
);
10375 do_cleanups (back_to
);
10379 remote_delete_command (char *args
, int from_tty
)
10381 struct cleanup
*back_to
;
10385 error_no_arg (_("file to delete"));
10387 argv
= gdb_buildargv (args
);
10388 back_to
= make_cleanup_freeargv (argv
);
10389 if (argv
[0] == NULL
|| argv
[1] != NULL
)
10390 error (_("Invalid parameters to remote delete"));
10392 remote_file_delete (argv
[0], from_tty
);
10394 do_cleanups (back_to
);
10398 remote_command (char *args
, int from_tty
)
10400 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
10404 remote_can_execute_reverse (void)
10406 if (remote_protocol_packets
[PACKET_bs
].support
== PACKET_ENABLE
10407 || remote_protocol_packets
[PACKET_bc
].support
== PACKET_ENABLE
)
10414 remote_supports_non_stop (void)
10420 remote_supports_disable_randomization (void)
10422 /* Only supported in extended mode. */
10427 remote_supports_multi_process (void)
10429 struct remote_state
*rs
= get_remote_state ();
10431 /* Only extended-remote handles being attached to multiple
10432 processes, even though plain remote can use the multi-process
10433 thread id extensions, so that GDB knows the target process's
10435 return rs
->extended
&& remote_multi_process_p (rs
);
10439 remote_supports_cond_tracepoints (void)
10441 struct remote_state
*rs
= get_remote_state ();
10443 return rs
->cond_tracepoints
;
10447 remote_supports_cond_breakpoints (void)
10449 struct remote_state
*rs
= get_remote_state ();
10451 return rs
->cond_breakpoints
;
10455 remote_supports_fast_tracepoints (void)
10457 struct remote_state
*rs
= get_remote_state ();
10459 return rs
->fast_tracepoints
;
10463 remote_supports_static_tracepoints (void)
10465 struct remote_state
*rs
= get_remote_state ();
10467 return rs
->static_tracepoints
;
10471 remote_supports_install_in_trace (void)
10473 struct remote_state
*rs
= get_remote_state ();
10475 return rs
->install_in_trace
;
10479 remote_supports_enable_disable_tracepoint (void)
10481 struct remote_state
*rs
= get_remote_state ();
10483 return rs
->enable_disable_tracepoints
;
10487 remote_supports_string_tracing (void)
10489 struct remote_state
*rs
= get_remote_state ();
10491 return rs
->string_tracing
;
10495 remote_can_run_breakpoint_commands (void)
10497 struct remote_state
*rs
= get_remote_state ();
10499 return rs
->breakpoint_commands
;
10503 remote_trace_init (void)
10506 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10507 if (strcmp (target_buf
, "OK") != 0)
10508 error (_("Target does not support this command."));
10511 static void free_actions_list (char **actions_list
);
10512 static void free_actions_list_cleanup_wrapper (void *);
10514 free_actions_list_cleanup_wrapper (void *al
)
10516 free_actions_list (al
);
10520 free_actions_list (char **actions_list
)
10524 if (actions_list
== 0)
10527 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
10528 xfree (actions_list
[ndx
]);
10530 xfree (actions_list
);
10533 /* Recursive routine to walk through command list including loops, and
10534 download packets for each command. */
10537 remote_download_command_source (int num
, ULONGEST addr
,
10538 struct command_line
*cmds
)
10540 struct remote_state
*rs
= get_remote_state ();
10541 struct command_line
*cmd
;
10543 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
10545 QUIT
; /* Allow user to bail out with ^C. */
10546 strcpy (rs
->buf
, "QTDPsrc:");
10547 encode_source_string (num
, addr
, "cmd", cmd
->line
,
10548 rs
->buf
+ strlen (rs
->buf
),
10549 rs
->buf_size
- strlen (rs
->buf
));
10551 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10552 if (strcmp (target_buf
, "OK"))
10553 warning (_("Target does not support source download."));
10555 if (cmd
->control_type
== while_control
10556 || cmd
->control_type
== while_stepping_control
)
10558 remote_download_command_source (num
, addr
, *cmd
->body_list
);
10560 QUIT
; /* Allow user to bail out with ^C. */
10561 strcpy (rs
->buf
, "QTDPsrc:");
10562 encode_source_string (num
, addr
, "cmd", "end",
10563 rs
->buf
+ strlen (rs
->buf
),
10564 rs
->buf_size
- strlen (rs
->buf
));
10566 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10567 if (strcmp (target_buf
, "OK"))
10568 warning (_("Target does not support source download."));
10574 remote_download_tracepoint (struct bp_location
*loc
)
10576 #define BUF_SIZE 2048
10580 char buf
[BUF_SIZE
];
10581 char **tdp_actions
;
10582 char **stepping_actions
;
10584 struct cleanup
*old_chain
= NULL
;
10585 struct agent_expr
*aexpr
;
10586 struct cleanup
*aexpr_chain
= NULL
;
10588 struct breakpoint
*b
= loc
->owner
;
10589 struct tracepoint
*t
= (struct tracepoint
*) b
;
10591 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
10592 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
10594 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
10597 tpaddr
= loc
->address
;
10598 sprintf_vma (addrbuf
, tpaddr
);
10599 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
10600 addrbuf
, /* address */
10601 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
10602 t
->step_count
, t
->pass_count
);
10603 /* Fast tracepoints are mostly handled by the target, but we can
10604 tell the target how big of an instruction block should be moved
10606 if (b
->type
== bp_fast_tracepoint
)
10608 /* Only test for support at download time; we may not know
10609 target capabilities at definition time. */
10610 if (remote_supports_fast_tracepoints ())
10614 if (gdbarch_fast_tracepoint_valid_at (target_gdbarch (),
10615 tpaddr
, &isize
, NULL
))
10616 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
10619 /* If it passed validation at definition but fails now,
10620 something is very wrong. */
10621 internal_error (__FILE__
, __LINE__
,
10622 _("Fast tracepoint not "
10623 "valid during download"));
10626 /* Fast tracepoints are functionally identical to regular
10627 tracepoints, so don't take lack of support as a reason to
10628 give up on the trace run. */
10629 warning (_("Target does not support fast tracepoints, "
10630 "downloading %d as regular tracepoint"), b
->number
);
10632 else if (b
->type
== bp_static_tracepoint
)
10634 /* Only test for support at download time; we may not know
10635 target capabilities at definition time. */
10636 if (remote_supports_static_tracepoints ())
10638 struct static_tracepoint_marker marker
;
10640 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
10641 strcat (buf
, ":S");
10643 error (_("Static tracepoint not valid during download"));
10646 /* Fast tracepoints are functionally identical to regular
10647 tracepoints, so don't take lack of support as a reason
10648 to give up on the trace run. */
10649 error (_("Target does not support static tracepoints"));
10651 /* If the tracepoint has a conditional, make it into an agent
10652 expression and append to the definition. */
10655 /* Only test support at download time, we may not know target
10656 capabilities at definition time. */
10657 if (remote_supports_cond_tracepoints ())
10659 aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
);
10660 aexpr_chain
= make_cleanup_free_agent_expr (aexpr
);
10661 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
10663 pkt
= buf
+ strlen (buf
);
10664 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
10665 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
10667 do_cleanups (aexpr_chain
);
10670 warning (_("Target does not support conditional tracepoints, "
10671 "ignoring tp %d cond"), b
->number
);
10674 if (b
->commands
|| *default_collect
)
10677 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10678 if (strcmp (target_buf
, "OK"))
10679 error (_("Target does not support tracepoints."));
10681 /* do_single_steps (t); */
10684 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
10686 QUIT
; /* Allow user to bail out with ^C. */
10687 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
10688 b
->number
, addrbuf
, /* address */
10690 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
10693 remote_get_noisy_reply (&target_buf
,
10695 if (strcmp (target_buf
, "OK"))
10696 error (_("Error on target while setting tracepoints."));
10699 if (stepping_actions
)
10701 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
10703 QUIT
; /* Allow user to bail out with ^C. */
10704 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
10705 b
->number
, addrbuf
, /* address */
10706 ((ndx
== 0) ? "S" : ""),
10707 stepping_actions
[ndx
],
10708 (stepping_actions
[ndx
+ 1] ? "-" : ""));
10710 remote_get_noisy_reply (&target_buf
,
10712 if (strcmp (target_buf
, "OK"))
10713 error (_("Error on target while setting tracepoints."));
10717 if (remote_protocol_packets
[PACKET_TracepointSource
].support
10720 if (b
->addr_string
)
10722 strcpy (buf
, "QTDPsrc:");
10723 encode_source_string (b
->number
, loc
->address
,
10724 "at", b
->addr_string
, buf
+ strlen (buf
),
10725 2048 - strlen (buf
));
10728 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10729 if (strcmp (target_buf
, "OK"))
10730 warning (_("Target does not support source download."));
10732 if (b
->cond_string
)
10734 strcpy (buf
, "QTDPsrc:");
10735 encode_source_string (b
->number
, loc
->address
,
10736 "cond", b
->cond_string
, buf
+ strlen (buf
),
10737 2048 - strlen (buf
));
10739 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10740 if (strcmp (target_buf
, "OK"))
10741 warning (_("Target does not support source download."));
10743 remote_download_command_source (b
->number
, loc
->address
,
10744 breakpoint_commands (b
));
10747 do_cleanups (old_chain
);
10751 remote_can_download_tracepoint (void)
10753 struct remote_state
*rs
= get_remote_state ();
10754 struct trace_status
*ts
;
10757 /* Don't try to install tracepoints until we've relocated our
10758 symbols, and fetched and merged the target's tracepoint list with
10760 if (rs
->starting_up
)
10763 ts
= current_trace_status ();
10764 status
= remote_get_trace_status (ts
);
10766 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
10769 /* If we are in a tracing experiment, but remote stub doesn't support
10770 installing tracepoint in trace, we have to return. */
10771 if (!remote_supports_install_in_trace ())
10779 remote_download_trace_state_variable (struct trace_state_variable
*tsv
)
10781 struct remote_state
*rs
= get_remote_state ();
10784 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
10785 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
10787 p
= rs
->buf
+ strlen (rs
->buf
);
10788 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
10789 error (_("Trace state variable name too long for tsv definition packet"));
10790 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, 0);
10793 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10794 if (*target_buf
== '\0')
10795 error (_("Target does not support this command."));
10796 if (strcmp (target_buf
, "OK") != 0)
10797 error (_("Error on target while downloading trace state variable."));
10801 remote_enable_tracepoint (struct bp_location
*location
)
10803 struct remote_state
*rs
= get_remote_state ();
10806 sprintf_vma (addr_buf
, location
->address
);
10807 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
10808 location
->owner
->number
, addr_buf
);
10810 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
10811 if (*rs
->buf
== '\0')
10812 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
10813 if (strcmp (rs
->buf
, "OK") != 0)
10814 error (_("Error on target while enabling tracepoint."));
10818 remote_disable_tracepoint (struct bp_location
*location
)
10820 struct remote_state
*rs
= get_remote_state ();
10823 sprintf_vma (addr_buf
, location
->address
);
10824 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
10825 location
->owner
->number
, addr_buf
);
10827 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
10828 if (*rs
->buf
== '\0')
10829 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
10830 if (strcmp (rs
->buf
, "OK") != 0)
10831 error (_("Error on target while disabling tracepoint."));
10835 remote_trace_set_readonly_regions (void)
10839 bfd_size_type size
;
10845 return; /* No information to give. */
10847 strcpy (target_buf
, "QTro");
10848 offset
= strlen (target_buf
);
10849 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10851 char tmp1
[40], tmp2
[40];
10854 if ((s
->flags
& SEC_LOAD
) == 0 ||
10855 /* (s->flags & SEC_CODE) == 0 || */
10856 (s
->flags
& SEC_READONLY
) == 0)
10860 vma
= bfd_get_section_vma (abfd
, s
);
10861 size
= bfd_get_section_size (s
);
10862 sprintf_vma (tmp1
, vma
);
10863 sprintf_vma (tmp2
, vma
+ size
);
10864 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
10865 if (offset
+ sec_length
+ 1 > target_buf_size
)
10867 if (remote_protocol_packets
[PACKET_qXfer_traceframe_info
].support
10870 Too many sections for read-only sections definition packet."));
10873 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
10875 offset
+= sec_length
;
10879 putpkt (target_buf
);
10880 getpkt (&target_buf
, &target_buf_size
, 0);
10885 remote_trace_start (void)
10887 putpkt ("QTStart");
10888 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10889 if (*target_buf
== '\0')
10890 error (_("Target does not support this command."));
10891 if (strcmp (target_buf
, "OK") != 0)
10892 error (_("Bogus reply from target: %s"), target_buf
);
10896 remote_get_trace_status (struct trace_status
*ts
)
10898 /* Initialize it just to avoid a GCC false warning. */
10900 /* FIXME we need to get register block size some other way. */
10901 extern int trace_regblock_size
;
10902 volatile struct gdb_exception ex
;
10903 enum packet_result result
;
10905 if (remote_protocol_packets
[PACKET_qTStatus
].support
== PACKET_DISABLE
)
10908 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
10910 putpkt ("qTStatus");
10912 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
10914 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10918 if (ex
.error
!= TARGET_CLOSE_ERROR
)
10920 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
10923 throw_exception (ex
);
10926 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
10928 /* If the remote target doesn't do tracing, flag it. */
10929 if (result
== PACKET_UNKNOWN
)
10932 /* We're working with a live target. */
10933 ts
->filename
= NULL
;
10936 error (_("Bogus trace status reply from target: %s"), target_buf
);
10938 /* Function 'parse_trace_status' sets default value of each field of
10939 'ts' at first, so we don't have to do it here. */
10940 parse_trace_status (p
, ts
);
10942 return ts
->running
;
10946 remote_get_tracepoint_status (struct breakpoint
*bp
,
10947 struct uploaded_tp
*utp
)
10949 struct remote_state
*rs
= get_remote_state ();
10951 struct bp_location
*loc
;
10952 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
10953 size_t size
= get_remote_packet_size ();
10957 tp
->base
.hit_count
= 0;
10958 tp
->traceframe_usage
= 0;
10959 for (loc
= tp
->base
.loc
; loc
; loc
= loc
->next
)
10961 /* If the tracepoint was never downloaded, don't go asking for
10963 if (tp
->number_on_target
== 0)
10965 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
10966 phex_nz (loc
->address
, 0));
10968 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10969 if (reply
&& *reply
)
10972 parse_tracepoint_status (reply
+ 1, bp
, utp
);
10978 utp
->hit_count
= 0;
10979 utp
->traceframe_usage
= 0;
10980 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
10981 phex_nz (utp
->addr
, 0));
10983 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10984 if (reply
&& *reply
)
10987 parse_tracepoint_status (reply
+ 1, bp
, utp
);
10993 remote_trace_stop (void)
10996 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
10997 if (*target_buf
== '\0')
10998 error (_("Target does not support this command."));
10999 if (strcmp (target_buf
, "OK") != 0)
11000 error (_("Bogus reply from target: %s"), target_buf
);
11004 remote_trace_find (enum trace_find_type type
, int num
,
11005 CORE_ADDR addr1
, CORE_ADDR addr2
,
11008 struct remote_state
*rs
= get_remote_state ();
11009 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11011 int target_frameno
= -1, target_tracept
= -1;
11013 /* Lookups other than by absolute frame number depend on the current
11014 trace selected, so make sure it is correct on the remote end
11016 if (type
!= tfind_number
)
11017 set_remote_traceframe ();
11020 strcpy (p
, "QTFrame:");
11021 p
= strchr (p
, '\0');
11025 xsnprintf (p
, endbuf
- p
, "%x", num
);
11028 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
11031 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
11034 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
11035 phex_nz (addr2
, 0));
11037 case tfind_outside
:
11038 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
11039 phex_nz (addr2
, 0));
11042 error (_("Unknown trace find type %d"), type
);
11046 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
11047 if (*reply
== '\0')
11048 error (_("Target does not support this command."));
11050 while (reply
&& *reply
)
11055 target_frameno
= (int) strtol (p
, &reply
, 16);
11057 error (_("Unable to parse trace frame number"));
11058 /* Don't update our remote traceframe number cache on failure
11059 to select a remote traceframe. */
11060 if (target_frameno
== -1)
11065 target_tracept
= (int) strtol (p
, &reply
, 16);
11067 error (_("Unable to parse tracepoint number"));
11069 case 'O': /* "OK"? */
11070 if (reply
[1] == 'K' && reply
[2] == '\0')
11073 error (_("Bogus reply from target: %s"), reply
);
11076 error (_("Bogus reply from target: %s"), reply
);
11079 *tpp
= target_tracept
;
11081 rs
->remote_traceframe_number
= target_frameno
;
11082 return target_frameno
;
11086 remote_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
11088 struct remote_state
*rs
= get_remote_state ();
11092 set_remote_traceframe ();
11094 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
11096 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11097 if (reply
&& *reply
)
11101 unpack_varlen_hex (reply
+ 1, &uval
);
11102 *val
= (LONGEST
) uval
;
11110 remote_save_trace_data (const char *filename
)
11112 struct remote_state
*rs
= get_remote_state ();
11116 strcpy (p
, "QTSave:");
11118 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
11119 error (_("Remote file name too long for trace save packet"));
11120 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, 0);
11123 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11124 if (*reply
== '\0')
11125 error (_("Target does not support this command."));
11126 if (strcmp (reply
, "OK") != 0)
11127 error (_("Bogus reply from target: %s"), reply
);
11131 /* This is basically a memory transfer, but needs to be its own packet
11132 because we don't know how the target actually organizes its trace
11133 memory, plus we want to be able to ask for as much as possible, but
11134 not be unhappy if we don't get as much as we ask for. */
11137 remote_get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
11139 struct remote_state
*rs
= get_remote_state ();
11145 strcpy (p
, "qTBuffer:");
11147 p
+= hexnumstr (p
, offset
);
11149 p
+= hexnumstr (p
, len
);
11153 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11154 if (reply
&& *reply
)
11156 /* 'l' by itself means we're at the end of the buffer and
11157 there is nothing more to get. */
11161 /* Convert the reply into binary. Limit the number of bytes to
11162 convert according to our passed-in buffer size, rather than
11163 what was returned in the packet; if the target is
11164 unexpectedly generous and gives us a bigger reply than we
11165 asked for, we don't want to crash. */
11166 rslt
= hex2bin (target_buf
, buf
, len
);
11170 /* Something went wrong, flag as an error. */
11175 remote_set_disconnected_tracing (int val
)
11177 struct remote_state
*rs
= get_remote_state ();
11179 if (rs
->disconnected_tracing
)
11183 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
11185 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11186 if (*reply
== '\0')
11187 error (_("Target does not support this command."));
11188 if (strcmp (reply
, "OK") != 0)
11189 error (_("Bogus reply from target: %s"), reply
);
11192 warning (_("Target does not support disconnected tracing."));
11196 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
11198 struct thread_info
*info
= find_thread_ptid (ptid
);
11200 if (info
&& info
->private)
11201 return info
->private->core
;
11206 remote_set_circular_trace_buffer (int val
)
11208 struct remote_state
*rs
= get_remote_state ();
11211 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
11213 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11214 if (*reply
== '\0')
11215 error (_("Target does not support this command."));
11216 if (strcmp (reply
, "OK") != 0)
11217 error (_("Bogus reply from target: %s"), reply
);
11220 static struct traceframe_info
*
11221 remote_traceframe_info (void)
11225 /* If current traceframe is not selected, don't bother the remote
11227 if (get_traceframe_number () < 0)
11230 text
= target_read_stralloc (¤t_target
,
11231 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
11234 struct traceframe_info
*info
;
11235 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
11237 info
= parse_traceframe_info (text
);
11238 do_cleanups (back_to
);
11245 /* Handle the qTMinFTPILen packet. Returns the minimum length of
11246 instruction on which a fast tracepoint may be placed. Returns -1
11247 if the packet is not supported, and 0 if the minimum instruction
11248 length is unknown. */
11251 remote_get_min_fast_tracepoint_insn_len (void)
11253 struct remote_state
*rs
= get_remote_state ();
11256 /* If we're not debugging a process yet, the IPA can't be
11258 if (!target_has_execution
)
11261 /* Make sure the remote is pointing at the right process. */
11262 set_general_process ();
11264 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
11266 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11267 if (*reply
== '\0')
11271 ULONGEST min_insn_len
;
11273 unpack_varlen_hex (reply
, &min_insn_len
);
11275 return (int) min_insn_len
;
11280 remote_set_trace_buffer_size (LONGEST val
)
11282 if (remote_protocol_packets
[PACKET_QTBuffer_size
].support
11285 struct remote_state
*rs
= get_remote_state ();
11286 char *buf
= rs
->buf
;
11287 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11288 enum packet_result result
;
11290 gdb_assert (val
>= 0 || val
== -1);
11291 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
11292 /* Send -1 as literal "-1" to avoid host size dependency. */
11296 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
11299 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
11302 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
11303 result
= packet_ok (rs
->buf
,
11304 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
11306 if (result
!= PACKET_OK
)
11307 warning (_("Bogus reply from target: %s"), rs
->buf
);
11312 remote_set_trace_notes (const char *user
, const char *notes
,
11313 const char *stop_notes
)
11315 struct remote_state
*rs
= get_remote_state ();
11317 char *buf
= rs
->buf
;
11318 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11321 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
11324 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
11325 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, 0);
11331 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
11332 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, 0);
11338 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
11339 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, 0);
11343 /* Ensure the buffer is terminated. */
11347 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
11348 if (*reply
== '\0')
11351 if (strcmp (reply
, "OK") != 0)
11352 error (_("Bogus reply from target: %s"), reply
);
11358 remote_use_agent (int use
)
11360 if (remote_protocol_packets
[PACKET_QAgent
].support
!= PACKET_DISABLE
)
11362 struct remote_state
*rs
= get_remote_state ();
11364 /* If the stub supports QAgent. */
11365 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
11367 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11369 if (strcmp (rs
->buf
, "OK") == 0)
11380 remote_can_use_agent (void)
11382 return (remote_protocol_packets
[PACKET_QAgent
].support
!= PACKET_DISABLE
);
11385 struct btrace_target_info
11387 /* The ptid of the traced thread. */
11391 /* Check whether the target supports branch tracing. */
11394 remote_supports_btrace (void)
11396 if (remote_protocol_packets
[PACKET_Qbtrace_off
].support
!= PACKET_ENABLE
)
11398 if (remote_protocol_packets
[PACKET_Qbtrace_bts
].support
!= PACKET_ENABLE
)
11400 if (remote_protocol_packets
[PACKET_qXfer_btrace
].support
!= PACKET_ENABLE
)
11406 /* Enable branch tracing. */
11408 static struct btrace_target_info
*
11409 remote_enable_btrace (ptid_t ptid
)
11411 struct btrace_target_info
*tinfo
= NULL
;
11412 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
11413 struct remote_state
*rs
= get_remote_state ();
11414 char *buf
= rs
->buf
;
11415 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11417 if (packet
->support
!= PACKET_ENABLE
)
11418 error (_("Target does not support branch tracing."));
11420 set_general_thread (ptid
);
11422 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
11424 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11426 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
11428 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
11429 error (_("Could not enable branch tracing for %s: %s"),
11430 target_pid_to_str (ptid
), rs
->buf
+ 2);
11432 error (_("Could not enable branch tracing for %s."),
11433 target_pid_to_str (ptid
));
11436 tinfo
= xzalloc (sizeof (*tinfo
));
11437 tinfo
->ptid
= ptid
;
11442 /* Disable branch tracing. */
11445 remote_disable_btrace (struct btrace_target_info
*tinfo
)
11447 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
11448 struct remote_state
*rs
= get_remote_state ();
11449 char *buf
= rs
->buf
;
11450 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
11452 if (packet
->support
!= PACKET_ENABLE
)
11453 error (_("Target does not support branch tracing."));
11455 set_general_thread (tinfo
->ptid
);
11457 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
11459 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11461 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
11463 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
11464 error (_("Could not disable branch tracing for %s: %s"),
11465 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
11467 error (_("Could not disable branch tracing for %s."),
11468 target_pid_to_str (tinfo
->ptid
));
11474 /* Teardown branch tracing. */
11477 remote_teardown_btrace (struct btrace_target_info
*tinfo
)
11479 /* We must not talk to the target during teardown. */
11483 /* Read the branch trace. */
11485 static enum btrace_error
11486 remote_read_btrace (VEC (btrace_block_s
) **btrace
,
11487 struct btrace_target_info
*tinfo
,
11488 enum btrace_read_type type
)
11490 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
11491 struct remote_state
*rs
= get_remote_state ();
11492 struct cleanup
*cleanup
;
11496 if (packet
->support
!= PACKET_ENABLE
)
11497 error (_("Target does not support branch tracing."));
11499 #if !defined(HAVE_LIBEXPAT)
11500 error (_("Cannot process branch tracing result. XML parsing not supported."));
11505 case BTRACE_READ_ALL
:
11508 case BTRACE_READ_NEW
:
11511 case BTRACE_READ_DELTA
:
11515 internal_error (__FILE__
, __LINE__
,
11516 _("Bad branch tracing read type: %u."),
11517 (unsigned int) type
);
11520 xml
= target_read_stralloc (¤t_target
,
11521 TARGET_OBJECT_BTRACE
, annex
);
11523 return BTRACE_ERR_UNKNOWN
;
11525 cleanup
= make_cleanup (xfree
, xml
);
11526 *btrace
= parse_xml_btrace (xml
);
11527 do_cleanups (cleanup
);
11529 return BTRACE_ERR_NONE
;
11533 remote_augmented_libraries_svr4_read (void)
11535 struct remote_state
*rs
= get_remote_state ();
11537 return rs
->augmented_libraries_svr4_read
;
11541 init_remote_ops (void)
11543 remote_ops
.to_shortname
= "remote";
11544 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
11545 remote_ops
.to_doc
=
11546 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
11547 Specify the serial device it is connected to\n\
11548 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
11549 remote_ops
.to_open
= remote_open
;
11550 remote_ops
.to_close
= remote_close
;
11551 remote_ops
.to_detach
= remote_detach
;
11552 remote_ops
.to_disconnect
= remote_disconnect
;
11553 remote_ops
.to_resume
= remote_resume
;
11554 remote_ops
.to_wait
= remote_wait
;
11555 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
11556 remote_ops
.to_store_registers
= remote_store_registers
;
11557 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
11558 remote_ops
.to_files_info
= remote_files_info
;
11559 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
11560 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
11561 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
11562 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
11563 remote_ops
.to_watchpoint_addr_within_range
=
11564 remote_watchpoint_addr_within_range
;
11565 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
11566 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
11567 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
11568 remote_ops
.to_region_ok_for_hw_watchpoint
11569 = remote_region_ok_for_hw_watchpoint
;
11570 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
11571 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
11572 remote_ops
.to_kill
= remote_kill
;
11573 remote_ops
.to_load
= generic_load
;
11574 remote_ops
.to_mourn_inferior
= remote_mourn
;
11575 remote_ops
.to_pass_signals
= remote_pass_signals
;
11576 remote_ops
.to_program_signals
= remote_program_signals
;
11577 remote_ops
.to_thread_alive
= remote_thread_alive
;
11578 remote_ops
.to_find_new_threads
= remote_threads_info
;
11579 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
11580 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
11581 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
11582 remote_ops
.to_stop
= remote_stop
;
11583 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
11584 remote_ops
.to_rcmd
= remote_rcmd
;
11585 remote_ops
.to_log_command
= serial_log_command
;
11586 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
11587 remote_ops
.to_stratum
= process_stratum
;
11588 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
11589 remote_ops
.to_has_memory
= default_child_has_memory
;
11590 remote_ops
.to_has_stack
= default_child_has_stack
;
11591 remote_ops
.to_has_registers
= default_child_has_registers
;
11592 remote_ops
.to_has_execution
= default_child_has_execution
;
11593 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
11594 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
11595 remote_ops
.to_magic
= OPS_MAGIC
;
11596 remote_ops
.to_memory_map
= remote_memory_map
;
11597 remote_ops
.to_flash_erase
= remote_flash_erase
;
11598 remote_ops
.to_flash_done
= remote_flash_done
;
11599 remote_ops
.to_read_description
= remote_read_description
;
11600 remote_ops
.to_search_memory
= remote_search_memory
;
11601 remote_ops
.to_can_async_p
= remote_can_async_p
;
11602 remote_ops
.to_is_async_p
= remote_is_async_p
;
11603 remote_ops
.to_async
= remote_async
;
11604 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
11605 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
11606 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
11607 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
11608 remote_ops
.to_supports_disable_randomization
11609 = remote_supports_disable_randomization
;
11610 remote_ops
.to_fileio_open
= remote_hostio_open
;
11611 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
11612 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
11613 remote_ops
.to_fileio_close
= remote_hostio_close
;
11614 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
11615 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
11616 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
11617 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
11618 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
11619 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
11620 remote_ops
.to_trace_init
= remote_trace_init
;
11621 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
11622 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
11623 remote_ops
.to_download_trace_state_variable
11624 = remote_download_trace_state_variable
;
11625 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
11626 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
11627 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
11628 remote_ops
.to_trace_start
= remote_trace_start
;
11629 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
11630 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
11631 remote_ops
.to_trace_stop
= remote_trace_stop
;
11632 remote_ops
.to_trace_find
= remote_trace_find
;
11633 remote_ops
.to_get_trace_state_variable_value
11634 = remote_get_trace_state_variable_value
;
11635 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
11636 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
11637 remote_ops
.to_upload_trace_state_variables
11638 = remote_upload_trace_state_variables
;
11639 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
11640 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
11641 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
11642 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
11643 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
11644 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
11645 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
11646 remote_ops
.to_verify_memory
= remote_verify_memory
;
11647 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
11648 remote_ops
.to_set_permissions
= remote_set_permissions
;
11649 remote_ops
.to_static_tracepoint_marker_at
11650 = remote_static_tracepoint_marker_at
;
11651 remote_ops
.to_static_tracepoint_markers_by_strid
11652 = remote_static_tracepoint_markers_by_strid
;
11653 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
11654 remote_ops
.to_use_agent
= remote_use_agent
;
11655 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
11656 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
11657 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
11658 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
11659 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
11660 remote_ops
.to_read_btrace
= remote_read_btrace
;
11661 remote_ops
.to_augmented_libraries_svr4_read
=
11662 remote_augmented_libraries_svr4_read
;
11665 /* Set up the extended remote vector by making a copy of the standard
11666 remote vector and adding to it. */
11669 init_extended_remote_ops (void)
11671 extended_remote_ops
= remote_ops
;
11673 extended_remote_ops
.to_shortname
= "extended-remote";
11674 extended_remote_ops
.to_longname
=
11675 "Extended remote serial target in gdb-specific protocol";
11676 extended_remote_ops
.to_doc
=
11677 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
11678 Specify the serial device it is connected to (e.g. /dev/ttya).";
11679 extended_remote_ops
.to_open
= extended_remote_open
;
11680 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
11681 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
11682 extended_remote_ops
.to_detach
= extended_remote_detach
;
11683 extended_remote_ops
.to_attach
= extended_remote_attach
;
11684 extended_remote_ops
.to_kill
= extended_remote_kill
;
11685 extended_remote_ops
.to_supports_disable_randomization
11686 = extended_remote_supports_disable_randomization
;
11690 remote_can_async_p (void)
11692 struct remote_state
*rs
= get_remote_state ();
11694 if (!target_async_permitted
)
11695 /* We only enable async when the user specifically asks for it. */
11698 /* We're async whenever the serial device is. */
11699 return serial_can_async_p (rs
->remote_desc
);
11703 remote_is_async_p (void)
11705 struct remote_state
*rs
= get_remote_state ();
11707 if (!target_async_permitted
)
11708 /* We only enable async when the user specifically asks for it. */
11711 /* We're async whenever the serial device is. */
11712 return serial_is_async_p (rs
->remote_desc
);
11715 /* Pass the SERIAL event on and up to the client. One day this code
11716 will be able to delay notifying the client of an event until the
11717 point where an entire packet has been received. */
11719 static serial_event_ftype remote_async_serial_handler
;
11722 remote_async_serial_handler (struct serial
*scb
, void *context
)
11724 struct remote_state
*rs
= context
;
11726 /* Don't propogate error information up to the client. Instead let
11727 the client find out about the error by querying the target. */
11728 rs
->async_client_callback (INF_REG_EVENT
, rs
->async_client_context
);
11732 remote_async_inferior_event_handler (gdb_client_data data
)
11734 inferior_event_handler (INF_REG_EVENT
, NULL
);
11738 remote_async (void (*callback
) (enum inferior_event_type event_type
,
11739 void *context
), void *context
)
11741 struct remote_state
*rs
= get_remote_state ();
11743 if (callback
!= NULL
)
11745 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
11746 rs
->async_client_callback
= callback
;
11747 rs
->async_client_context
= context
;
11750 serial_async (rs
->remote_desc
, NULL
, NULL
);
11754 set_remote_cmd (char *args
, int from_tty
)
11756 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
11760 show_remote_cmd (char *args
, int from_tty
)
11762 /* We can't just use cmd_show_list here, because we want to skip
11763 the redundant "show remote Z-packet" and the legacy aliases. */
11764 struct cleanup
*showlist_chain
;
11765 struct cmd_list_element
*list
= remote_show_cmdlist
;
11766 struct ui_out
*uiout
= current_uiout
;
11768 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
11769 for (; list
!= NULL
; list
= list
->next
)
11770 if (strcmp (list
->name
, "Z-packet") == 0)
11772 else if (list
->type
== not_set_cmd
)
11773 /* Alias commands are exactly like the original, except they
11774 don't have the normal type. */
11778 struct cleanup
*option_chain
11779 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
11781 ui_out_field_string (uiout
, "name", list
->name
);
11782 ui_out_text (uiout
, ": ");
11783 if (list
->type
== show_cmd
)
11784 do_show_command ((char *) NULL
, from_tty
, list
);
11786 cmd_func (list
, NULL
, from_tty
);
11787 /* Close the tuple. */
11788 do_cleanups (option_chain
);
11791 /* Close the tuple. */
11792 do_cleanups (showlist_chain
);
11796 /* Function to be called whenever a new objfile (shlib) is detected. */
11798 remote_new_objfile (struct objfile
*objfile
)
11800 struct remote_state
*rs
= get_remote_state ();
11802 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
11803 remote_check_symbols ();
11806 /* Pull all the tracepoints defined on the target and create local
11807 data structures representing them. We don't want to create real
11808 tracepoints yet, we don't want to mess up the user's existing
11812 remote_upload_tracepoints (struct uploaded_tp
**utpp
)
11814 struct remote_state
*rs
= get_remote_state ();
11817 /* Ask for a first packet of tracepoint definition. */
11819 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11821 while (*p
&& *p
!= 'l')
11823 parse_tracepoint_definition (p
, utpp
);
11824 /* Ask for another packet of tracepoint definition. */
11826 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11833 remote_upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
11835 struct remote_state
*rs
= get_remote_state ();
11838 /* Ask for a first packet of variable definition. */
11840 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11842 while (*p
&& *p
!= 'l')
11844 parse_tsv_definition (p
, utsvp
);
11845 /* Ask for another packet of variable definition. */
11847 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11853 /* The "set/show range-stepping" show hook. */
11856 show_range_stepping (struct ui_file
*file
, int from_tty
,
11857 struct cmd_list_element
*c
,
11860 fprintf_filtered (file
,
11861 _("Debugger's willingness to use range stepping "
11862 "is %s.\n"), value
);
11865 /* The "set/show range-stepping" set hook. */
11868 set_range_stepping (char *ignore_args
, int from_tty
,
11869 struct cmd_list_element
*c
)
11871 struct remote_state
*rs
= get_remote_state ();
11873 /* Whene enabling, check whether range stepping is actually
11874 supported by the target, and warn if not. */
11875 if (use_range_stepping
)
11877 if (rs
->remote_desc
!= NULL
)
11879 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
11880 remote_vcont_probe (rs
);
11882 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_ENABLE
11883 && rs
->supports_vCont
.r
)
11887 warning (_("Range stepping is not supported by the current target"));
11892 _initialize_remote (void)
11894 struct remote_state
*rs
;
11895 struct cmd_list_element
*cmd
;
11896 const char *cmd_name
;
11898 /* architecture specific data */
11899 remote_gdbarch_data_handle
=
11900 gdbarch_data_register_post_init (init_remote_state
);
11901 remote_g_packet_data_handle
=
11902 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
11904 /* Initialize the per-target state. At the moment there is only one
11905 of these, not one per target. Only one target is active at a
11907 remote_state
= new_remote_state ();
11909 init_remote_ops ();
11910 add_target (&remote_ops
);
11912 init_extended_remote_ops ();
11913 add_target (&extended_remote_ops
);
11915 /* Hook into new objfile notification. */
11916 observer_attach_new_objfile (remote_new_objfile
);
11917 /* We're no longer interested in notification events of an inferior
11919 observer_attach_inferior_exit (discard_pending_stop_replies
);
11921 /* Set up signal handlers. */
11922 async_sigint_remote_token
=
11923 create_async_signal_handler (async_remote_interrupt
, NULL
);
11924 async_sigint_remote_twice_token
=
11925 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
11928 init_remote_threadtests ();
11931 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
11932 /* set/show remote ... */
11934 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
11935 Remote protocol specific variables\n\
11936 Configure various remote-protocol specific variables such as\n\
11937 the packets being used"),
11938 &remote_set_cmdlist
, "set remote ",
11939 0 /* allow-unknown */, &setlist
);
11940 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
11941 Remote protocol specific variables\n\
11942 Configure various remote-protocol specific variables such as\n\
11943 the packets being used"),
11944 &remote_show_cmdlist
, "show remote ",
11945 0 /* allow-unknown */, &showlist
);
11947 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
11948 Compare section data on target to the exec file.\n\
11949 Argument is a single section name (default: all loaded sections)."),
11952 add_cmd ("packet", class_maintenance
, packet_command
, _("\
11953 Send an arbitrary packet to a remote target.\n\
11954 maintenance packet TEXT\n\
11955 If GDB is talking to an inferior via the GDB serial protocol, then\n\
11956 this command sends the string TEXT to the inferior, and displays the\n\
11957 response packet. GDB supplies the initial `$' character, and the\n\
11958 terminating `#' character and checksum."),
11961 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
11962 Set whether to send break if interrupted."), _("\
11963 Show whether to send break if interrupted."), _("\
11964 If set, a break, instead of a cntrl-c, is sent to the remote target."),
11965 set_remotebreak
, show_remotebreak
,
11966 &setlist
, &showlist
);
11967 cmd_name
= "remotebreak";
11968 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
11969 deprecate_cmd (cmd
, "set remote interrupt-sequence");
11970 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
11971 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
11972 deprecate_cmd (cmd
, "show remote interrupt-sequence");
11974 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
11975 interrupt_sequence_modes
, &interrupt_sequence_mode
,
11977 Set interrupt sequence to remote target."), _("\
11978 Show interrupt sequence to remote target."), _("\
11979 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
11980 NULL
, show_interrupt_sequence
,
11981 &remote_set_cmdlist
,
11982 &remote_show_cmdlist
);
11984 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
11985 &interrupt_on_connect
, _("\
11986 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
11987 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
11988 If set, interrupt sequence is sent to remote target."),
11990 &remote_set_cmdlist
, &remote_show_cmdlist
);
11992 /* Install commands for configuring memory read/write packets. */
11994 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
11995 Set the maximum number of bytes per memory write packet (deprecated)."),
11997 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
11998 Show the maximum number of bytes per memory write packet (deprecated)."),
12000 add_cmd ("memory-write-packet-size", no_class
,
12001 set_memory_write_packet_size
, _("\
12002 Set the maximum number of bytes per memory-write packet.\n\
12003 Specify the number of bytes in a packet or 0 (zero) for the\n\
12004 default packet size. The actual limit is further reduced\n\
12005 dependent on the target. Specify ``fixed'' to disable the\n\
12006 further restriction and ``limit'' to enable that restriction."),
12007 &remote_set_cmdlist
);
12008 add_cmd ("memory-read-packet-size", no_class
,
12009 set_memory_read_packet_size
, _("\
12010 Set the maximum number of bytes per memory-read packet.\n\
12011 Specify the number of bytes in a packet or 0 (zero) for the\n\
12012 default packet size. The actual limit is further reduced\n\
12013 dependent on the target. Specify ``fixed'' to disable the\n\
12014 further restriction and ``limit'' to enable that restriction."),
12015 &remote_set_cmdlist
);
12016 add_cmd ("memory-write-packet-size", no_class
,
12017 show_memory_write_packet_size
,
12018 _("Show the maximum number of bytes per memory-write packet."),
12019 &remote_show_cmdlist
);
12020 add_cmd ("memory-read-packet-size", no_class
,
12021 show_memory_read_packet_size
,
12022 _("Show the maximum number of bytes per memory-read packet."),
12023 &remote_show_cmdlist
);
12025 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
12026 &remote_hw_watchpoint_limit
, _("\
12027 Set the maximum number of target hardware watchpoints."), _("\
12028 Show the maximum number of target hardware watchpoints."), _("\
12029 Specify a negative limit for unlimited."),
12030 NULL
, NULL
, /* FIXME: i18n: The maximum
12031 number of target hardware
12032 watchpoints is %s. */
12033 &remote_set_cmdlist
, &remote_show_cmdlist
);
12034 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
12035 &remote_hw_watchpoint_length_limit
, _("\
12036 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
12037 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
12038 Specify a negative limit for unlimited."),
12039 NULL
, NULL
, /* FIXME: i18n: The maximum
12040 length (in bytes) of a target
12041 hardware watchpoint is %s. */
12042 &remote_set_cmdlist
, &remote_show_cmdlist
);
12043 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
12044 &remote_hw_breakpoint_limit
, _("\
12045 Set the maximum number of target hardware breakpoints."), _("\
12046 Show the maximum number of target hardware breakpoints."), _("\
12047 Specify a negative limit for unlimited."),
12048 NULL
, NULL
, /* FIXME: i18n: The maximum
12049 number of target hardware
12050 breakpoints is %s. */
12051 &remote_set_cmdlist
, &remote_show_cmdlist
);
12053 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
12054 &remote_address_size
, _("\
12055 Set the maximum size of the address (in bits) in a memory packet."), _("\
12056 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
12058 NULL
, /* FIXME: i18n: */
12059 &setlist
, &showlist
);
12061 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
12062 "X", "binary-download", 1);
12064 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
12065 "vCont", "verbose-resume", 0);
12067 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
12068 "QPassSignals", "pass-signals", 0);
12070 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
12071 "QProgramSignals", "program-signals", 0);
12073 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
12074 "qSymbol", "symbol-lookup", 0);
12076 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
12077 "P", "set-register", 1);
12079 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
12080 "p", "fetch-register", 1);
12082 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
12083 "Z0", "software-breakpoint", 0);
12085 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
12086 "Z1", "hardware-breakpoint", 0);
12088 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
12089 "Z2", "write-watchpoint", 0);
12091 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
12092 "Z3", "read-watchpoint", 0);
12094 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
12095 "Z4", "access-watchpoint", 0);
12097 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
12098 "qXfer:auxv:read", "read-aux-vector", 0);
12100 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
12101 "qXfer:features:read", "target-features", 0);
12103 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
12104 "qXfer:libraries:read", "library-info", 0);
12106 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
12107 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
12109 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
12110 "qXfer:memory-map:read", "memory-map", 0);
12112 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
12113 "qXfer:spu:read", "read-spu-object", 0);
12115 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
12116 "qXfer:spu:write", "write-spu-object", 0);
12118 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
12119 "qXfer:osdata:read", "osdata", 0);
12121 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
12122 "qXfer:threads:read", "threads", 0);
12124 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
12125 "qXfer:siginfo:read", "read-siginfo-object", 0);
12127 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
12128 "qXfer:siginfo:write", "write-siginfo-object", 0);
12130 add_packet_config_cmd
12131 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
12132 "qXfer:traceframe-info:read", "traceframe-info", 0);
12134 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
12135 "qXfer:uib:read", "unwind-info-block", 0);
12137 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
12138 "qGetTLSAddr", "get-thread-local-storage-address",
12141 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
12142 "qGetTIBAddr", "get-thread-information-block-address",
12145 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
12146 "bc", "reverse-continue", 0);
12148 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
12149 "bs", "reverse-step", 0);
12151 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
12152 "qSupported", "supported-packets", 0);
12154 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
12155 "qSearch:memory", "search-memory", 0);
12157 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
12158 "qTStatus", "trace-status", 0);
12160 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
12161 "vFile:open", "hostio-open", 0);
12163 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
12164 "vFile:pread", "hostio-pread", 0);
12166 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
12167 "vFile:pwrite", "hostio-pwrite", 0);
12169 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
12170 "vFile:close", "hostio-close", 0);
12172 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
12173 "vFile:unlink", "hostio-unlink", 0);
12175 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
12176 "vFile:readlink", "hostio-readlink", 0);
12178 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
12179 "vAttach", "attach", 0);
12181 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
12184 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
12185 "QStartNoAckMode", "noack", 0);
12187 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
12188 "vKill", "kill", 0);
12190 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
12191 "qAttached", "query-attached", 0);
12193 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
12194 "ConditionalTracepoints",
12195 "conditional-tracepoints", 0);
12197 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
12198 "ConditionalBreakpoints",
12199 "conditional-breakpoints", 0);
12201 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
12202 "BreakpointCommands",
12203 "breakpoint-commands", 0);
12205 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
12206 "FastTracepoints", "fast-tracepoints", 0);
12208 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
12209 "TracepointSource", "TracepointSource", 0);
12211 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
12212 "QAllow", "allow", 0);
12214 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
12215 "StaticTracepoints", "static-tracepoints", 0);
12217 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
12218 "InstallInTrace", "install-in-trace", 0);
12220 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
12221 "qXfer:statictrace:read", "read-sdata-object", 0);
12223 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
12224 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
12226 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
12227 "QDisableRandomization", "disable-randomization", 0);
12229 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
12230 "QAgent", "agent", 0);
12232 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
12233 "QTBuffer:size", "trace-buffer-size", 0);
12235 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
12236 "Qbtrace:off", "disable-btrace", 0);
12238 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
12239 "Qbtrace:bts", "enable-btrace", 0);
12241 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
12242 "qXfer:btrace", "read-btrace", 0);
12244 /* Keep the old ``set remote Z-packet ...'' working. Each individual
12245 Z sub-packet has its own set and show commands, but users may
12246 have sets to this variable in their .gdbinit files (or in their
12248 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
12249 &remote_Z_packet_detect
, _("\
12250 Set use of remote protocol `Z' packets"), _("\
12251 Show use of remote protocol `Z' packets "), _("\
12252 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
12254 set_remote_protocol_Z_packet_cmd
,
12255 show_remote_protocol_Z_packet_cmd
,
12256 /* FIXME: i18n: Use of remote protocol
12257 `Z' packets is %s. */
12258 &remote_set_cmdlist
, &remote_show_cmdlist
);
12260 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
12261 Manipulate files on the remote system\n\
12262 Transfer files to and from the remote target system."),
12263 &remote_cmdlist
, "remote ",
12264 0 /* allow-unknown */, &cmdlist
);
12266 add_cmd ("put", class_files
, remote_put_command
,
12267 _("Copy a local file to the remote system."),
12270 add_cmd ("get", class_files
, remote_get_command
,
12271 _("Copy a remote file to the local system."),
12274 add_cmd ("delete", class_files
, remote_delete_command
,
12275 _("Delete a remote file."),
12278 remote_exec_file
= xstrdup ("");
12279 add_setshow_string_noescape_cmd ("exec-file", class_files
,
12280 &remote_exec_file
, _("\
12281 Set the remote pathname for \"run\""), _("\
12282 Show the remote pathname for \"run\""), NULL
, NULL
, NULL
,
12283 &remote_set_cmdlist
, &remote_show_cmdlist
);
12285 add_setshow_boolean_cmd ("range-stepping", class_run
,
12286 &use_range_stepping
, _("\
12287 Enable or disable range stepping."), _("\
12288 Show whether target-assisted range stepping is enabled."), _("\
12289 If on, and the target supports it, when stepping a source line, GDB\n\
12290 tells the target to step the corresponding range of addresses itself instead\n\
12291 of issuing multiple single-steps. This speeds up source level\n\
12292 stepping. If off, GDB always issues single-steps, even if range\n\
12293 stepping is supported by the target. The default is on."),
12294 set_range_stepping
,
12295 show_range_stepping
,
12299 /* Eventually initialize fileio. See fileio.c */
12300 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
12302 /* Take advantage of the fact that the LWP field is not used, to tag
12303 special ptids with it set to != 0. */
12304 magic_null_ptid
= ptid_build (42000, 1, -1);
12305 not_sent_ptid
= ptid_build (42000, 1, -2);
12306 any_thread_ptid
= ptid_build (42000, 1, 0);
12308 target_buf_size
= 2048;
12309 target_buf
= xmalloc (target_buf_size
);