/usr/src/gnu/usr.bin/binutils/gdb/remote.c

Bug Summary

File:	src/gnu/usr.bin/binutils/gdb/remote.c
Warning:	line 5002, column 9 Value stored to 'p' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name remote.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/remote.c

1	/* Remote target communications for serial-line targets in custom GDB protocol
2
3	Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4	1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5	Free Software Foundation, Inc.
6
7	This file is part of GDB.
8
9	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 2 of the License, or
12	(at your option) any later version.
13
14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with this program; if not, write to the Free Software
21	Foundation, Inc., 59 Temple Place - Suite 330,
22	Boston, MA 02111-1307, USA. */
23
24	/* See the GDB User Guide for details of the GDB remote protocol. */
25
26	#include "defs.h"
27	#include "gdb_string.h"
28	#include <ctype.h>
29	#include <fcntl.h>
30	#include "inferior.h"
31	#include "bfd.h"
32	#include "symfile.h"
33	#include "target.h"
34	/#include "terminal.h" /
35	#include "gdbcmd.h"
36	#include "objfiles.h"
37	#include "gdb-stabs.h"
38	#include "gdbthread.h"
39	#include "remote.h"
40	#include "regcache.h"
41	#include "value.h"
42	#include "gdb_assert.h"
43
44	#include <ctype.h>
45	#include <sys/time.h>
46
47	#include "event-loop.h"
48	#include "event-top.h"
49	#include "inf-loop.h"
50
51	#include <signal.h>
52	#include "serial.h"
53
54	#include "gdbcore.h" /* for exec_bfd */
55
56	#include "remote-fileio.h"
57
58	/* Prototypes for local functions */
59	static void cleanup_sigint_signal_handler (void *dummy);
60	static void initialize_sigint_signal_handler (void);
61	static int getpkt_sane (char *buf, long sizeof_buf, int forever);
62
63	static void handle_remote_sigint (int);
64	static void handle_remote_sigint_twice (int);
65	static void async_remote_interrupt (gdb_client_data);
66	void async_remote_interrupt_twice (gdb_client_data);
67
68	static void build_remote_gdbarch_data (void);
69
70	static void remote_files_info (struct target_ops *ignore);
71
72	static int remote_xfer_memory (CORE_ADDR memaddr, char *myaddr,
73	int len, int should_write,
74	struct mem_attrib *attrib,
75	struct target_ops *target);
76
77	static void remote_prepare_to_store (void);
78
79	static void remote_fetch_registers (int regno);
80
81	static void remote_resume (ptid_t ptid, int step,
82	enum target_signal siggnal);
83	static void remote_async_resume (ptid_t ptid, int step,
84	enum target_signal siggnal);
85	static int remote_start_remote (struct ui_out uiout, void dummy);
86
87	static void remote_open (char *name, int from_tty);
88	static void remote_async_open (char *name, int from_tty);
89
90	static void extended_remote_open (char *name, int from_tty);
91	static void extended_remote_async_open (char *name, int from_tty);
92
93	static void remote_open_1 (char , int, struct target_ops , int extended_p,
94	int async_p);
95
96	static void remote_close (int quitting);
97
98	static void remote_store_registers (int regno);
99
100	static void remote_mourn (void);
101	static void remote_async_mourn (void);
102
103	static void extended_remote_restart (void);
104
105	static void extended_remote_mourn (void);
106
107	static void remote_mourn_1 (struct target_ops *);
108
109	static void remote_send (char *buf, long sizeof_buf);
110
111	static int readchar (int timeout);
112
113	static ptid_t remote_wait (ptid_t ptid,
114	struct target_waitstatus *status);
115	static ptid_t remote_async_wait (ptid_t ptid,
116	struct target_waitstatus *status);
117
118	static void remote_kill (void);
119	static void remote_async_kill (void);
120
121	static int tohex (int nib);
122
123	static void remote_detach (char *args, int from_tty);
124
125	static void remote_interrupt (int signo);
126
127	static void remote_interrupt_twice (int signo);
128
129	static void interrupt_query (void);
130
131	static void set_thread (int, int);
132
133	static int remote_thread_alive (ptid_t);
134
135	static void get_offsets (void);
136
137	static long read_frame (char *buf, long sizeof_buf);
138
139	static int remote_insert_breakpoint (CORE_ADDR, char *);
140
141	static int remote_remove_breakpoint (CORE_ADDR, char *);
142
143	static int hexnumlen (ULONGESTunsigned long num);
144
145	static void init_remote_ops (void);
146
147	static void init_extended_remote_ops (void);
148
149	static void remote_stop (void);
150
151	static int ishex (int ch, int *val);
152
153	static int stubhex (int ch);
154
155	static int hexnumstr (char *, ULONGESTunsigned long);
156
157	static int hexnumnstr (char *, ULONGESTunsigned long, int);
158
159	static CORE_ADDR remote_address_masked (CORE_ADDR);
160
161	static void print_packet (char *);
162
163	static unsigned long crc32 (unsigned char *, int, unsigned int);
164
165	static void compare_sections_command (char *, int);
166
167	static void packet_command (char *, int);
168
169	static int stub_unpack_int (char *buff, int fieldlength);
170
171	static ptid_t remote_current_thread (ptid_t oldptid);
172
173	static void remote_find_new_threads (void);
174
175	static void record_currthread (int currthread);
176
177	static int fromhex (int a);
178
179	static int hex2bin (const char hex, char bin, int count);
180
181	static int bin2hex (const char bin, char hex, int count);
182
183	static int putpkt_binary (char *buf, int cnt);
184
185	static void check_binary_download (CORE_ADDR addr);
186
187	struct packet_config;
188
189	static void show_packet_config_cmd (struct packet_config *config);
190
191	static void update_packet_config (struct packet_config *config);
192
193	void _initialize_remote (void);
194
195	/* Description of the remote protocol. Strictly speaking, when the
196	target is open()ed, remote.c should create a per-target description
197	of the remote protocol using that target's architecture.
198	Unfortunately, the target stack doesn't include local state. For
199	the moment keep the information in the target's architecture
200	object. Sigh.. */
201
202	struct packet_reg
203	{
204	long offset; /* Offset into G packet. */
205	long regnum; /* GDB's internal register number. */
206	LONGESTlong pnum; /* Remote protocol register number. */
207	int in_g_packet; /* Always part of G packet. */
208	/* long size in bytes; == register_size (current_gdbarch, regnum); at present. */
209	/* char name; == REGISTER_NAME (regnum); at present. /
210	};
211
212	struct remote_state
213	{
214	/* Description of the remote protocol registers. */
215	long sizeof_g_packet;
216
217	/* Description of the remote protocol registers indexed by REGNUM
218	(making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
219	struct packet_reg *regs;
220
221	/* This is the size (in chars) of the first response to the ``g''
222	packet. It is used as a heuristic when determining the maximum
223	size of memory-read and memory-write packets. A target will
224	typically only reserve a buffer large enough to hold the ``g''
225	packet. The size does not include packet overhead (headers and
226	trailers). */
227	long actual_register_packet_size;
228
229	/* This is the maximum size (in chars) of a non read/write packet.
230	It is also used as a cap on the size of read/write packets. */
231	long remote_packet_size;
232	};
233
234
235	/* Handle for retreving the remote protocol data from gdbarch. */
236	static struct gdbarch_data *remote_gdbarch_data_handle;
237
238	static struct remote_state *
239	get_remote_state (void)
240	{
241	return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
242	}
243
244	static void *
245	init_remote_state (struct gdbarch *gdbarch)
246	{
247	int regnum;
248	struct remote_state rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state)((struct remote_state ) gdbarch_obstack_zalloc ((gdbarch), sizeof (struct remote_state)));
249
250	if (deprecated_register_bytes () != 0)
251	rs->sizeof_g_packet = deprecated_register_bytes ();
252	else
253	rs->sizeof_g_packet = 0;
254
255	/* Assume a 1:1 regnum<->pnum table. */
256	rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,((struct packet_reg ) gdbarch_obstack_zalloc ((gdbarch), ((gdbarch_num_regs (current_gdbarch)) + (gdbarch_num_pseudo_regs (current_gdbarch ))) sizeof (struct packet_reg)))
257	struct packet_reg)((struct packet_reg ) gdbarch_obstack_zalloc ((gdbarch), ((gdbarch_num_regs (current_gdbarch)) + (gdbarch_num_pseudo_regs (current_gdbarch ))) sizeof (struct packet_reg)));
258	for (regnum = 0; regnum < NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch)); regnum++)
259	{
260	struct packet_reg *r = &rs->regs[regnum];
261	r->pnum = regnum;
262	r->regnum = regnum;
263	r->offset = DEPRECATED_REGISTER_BYTE (regnum)(gdbarch_deprecated_register_byte (current_gdbarch, regnum));
264	r->in_g_packet = (regnum < NUM_REGS(gdbarch_num_regs (current_gdbarch)));
265	/* ...name = REGISTER_NAME (regnum); */
266
267	/* Compute packet size by accumulating the size of all registers. */
268	if (deprecated_register_bytes () == 0)
269	rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
270	}
271
272	/* Default maximum number of characters in a packet body. Many
273	remote stubs have a hardwired buffer size of 400 bytes
274	(c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
275	as the maximum packet-size to ensure that the packet and an extra
276	NUL character can always fit in the buffer. This stops GDB
277	trashing stubs that try to squeeze an extra NUL into what is
278	already a full buffer (As of 1999-12-04 that was most stubs. */
279	rs->remote_packet_size = 400 - 1;
280
281	/* Should rs->sizeof_g_packet needs more space than the
282	default, adjust the size accordingly. Remember that each byte is
283	encoded as two characters. 32 is the overhead for the packet
284	header / footer. NOTE: cagney/1999-10-26: I suspect that 8
285	(``$NN:G...#NN'') is a better guess, the below has been padded a
286	little. */
287	if (rs->sizeof_g_packet > ((rs->remote_packet_size - 32) / 2))
288	rs->remote_packet_size = (rs->sizeof_g_packet * 2 + 32);
289
290	/* This one is filled in when a ``g'' packet is received. */
291	rs->actual_register_packet_size = 0;
292
293	return rs;
294	}
295
296	static struct packet_reg *
297	packet_reg_from_regnum (struct remote_state *rs, long regnum)
298	{
299	if (regnum < 0 && regnum >= NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch)))
300	return NULL((void*)0);
301	else
302	{
303	struct packet_reg *r = &rs->regs[regnum];
304	gdb_assert (r->regnum == regnum)((void) ((r->regnum == regnum) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 304, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "r->regnum == regnum" ), 0)));
305	return r;
306	}
307	}
308
309	static struct packet_reg *
310	packet_reg_from_pnum (struct remote_state *rs, LONGESTlong pnum)
311	{
312	int i;
313	for (i = 0; i < NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch)); i++)
314	{
315	struct packet_reg *r = &rs->regs[i];
316	if (r->pnum == pnum)
317	return r;
318	}
319	return NULL((void*)0);
320	}
321
322	/* FIXME: graces/2002-08-08: These variables should eventually be
323	bound to an instance of the target object (as in gdbarch-tdep()),
324	when such a thing exists. */
325
326	/* This is set to the data address of the access causing the target
327	to stop for a watchpoint. */
328	static CORE_ADDR remote_watch_data_address;
329
330	/* This is non-zero if taregt stopped for a watchpoint. */
331	static int remote_stopped_by_watchpoint_p;
332
333
334	static struct target_ops remote_ops;
335
336	static struct target_ops extended_remote_ops;
337
338	/* Temporary target ops. Just like the remote_ops and
339	extended_remote_ops, but with asynchronous support. */
340	static struct target_ops remote_async_ops;
341
342	static struct target_ops extended_async_remote_ops;
343
344	/* FIXME: cagney/1999-09-23: Even though getpkt was called with
345	``forever'' still use the normal timeout mechanism. This is
346	currently used by the ASYNC code to guarentee that target reads
347	during the initial connect always time-out. Once getpkt has been
348	modified to return a timeout indication and, in turn
349	remote_wait()/wait_for_inferior() have gained a timeout parameter
350	this can go away. */
351	static int wait_forever_enabled_p = 1;
352
353
354	/* This variable chooses whether to send a ^C or a break when the user
355	requests program interruption. Although ^C is usually what remote
356	systems expect, and that is the default here, sometimes a break is
357	preferable instead. */
358
359	static int remote_break;
360
361	/* Descriptor for I/O to remote machine. Initialize it to NULL so that
362	remote_open knows that we don't have a file open when the program
363	starts. */
364	static struct serial remote_desc = NULL((void)0);
365
366	/* This variable sets the number of bits in an address that are to be
367	sent in a memory ("M" or "m") packet. Normally, after stripping
368	leading zeros, the entire address would be sent. This variable
369	restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
370	initial implementation of remote.c restricted the address sent in
371	memory packets to ``host::sizeof long'' bytes - (typically 32
372	bits). Consequently, for 64 bit targets, the upper 32 bits of an
373	address was never sent. Since fixing this bug may cause a break in
374	some remote targets this variable is principly provided to
375	facilitate backward compatibility. */
376
377	static int remote_address_size;
378
379	/* Tempoary to track who currently owns the terminal. See
380	target_async_terminal_* for more details. */
381
382	static int remote_async_terminal_ours_p;
383
384
385	/* User configurable variables for the number of characters in a
386	memory read/write packet. MIN ((rs->remote_packet_size),
387	rs->sizeof_g_packet) is the default. Some targets need smaller
388	values (fifo overruns, et.al.) and some users need larger values
389	(speed up transfers). The variables ``preferred_*'' (the user
390	request), ``current_'' (what was actually set) and ``forced_''
391	(Positive - a soft limit, negative - a hard limit). */
392
393	struct memory_packet_config
394	{
395	char *name;
396	long size;
397	int fixed_p;
398	};
399
400	/* Compute the current size of a read/write packet. Since this makes
401	use of ``actual_register_packet_size'' the computation is dynamic. */
402
403	static long
404	get_memory_packet_size (struct memory_packet_config *config)
405	{
406	struct remote_state *rs = get_remote_state ();
407	/* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
408	law?) that some hosts don't cope very well with large alloca()
409	calls. Eventually the alloca() code will be replaced by calls to
410	xmalloc() and make_cleanups() allowing this restriction to either
411	be lifted or removed. */
412	#ifndef MAX_REMOTE_PACKET_SIZE16384
413	#define MAX_REMOTE_PACKET_SIZE16384 16384
414	#endif
415	/* NOTE: 16 is just chosen at random. */
416	#ifndef MIN_REMOTE_PACKET_SIZE16
417	#define MIN_REMOTE_PACKET_SIZE16 16
418	#endif
419	long what_they_get;
420	if (config->fixed_p)
421	{
422	if (config->size <= 0)
423	what_they_get = MAX_REMOTE_PACKET_SIZE16384;
424	else
425	what_they_get = config->size;
426	}
427	else
428	{
429	what_they_get = (rs->remote_packet_size);
430	/* Limit the packet to the size specified by the user. */
431	if (config->size > 0
432	&& what_they_get > config->size)
433	what_they_get = config->size;
434	/* Limit it to the size of the targets ``g'' response. */
435	if ((rs->actual_register_packet_size) > 0
436	&& what_they_get > (rs->actual_register_packet_size))
437	what_they_get = (rs->actual_register_packet_size);
438	}
439	if (what_they_get > MAX_REMOTE_PACKET_SIZE16384)
440	what_they_get = MAX_REMOTE_PACKET_SIZE16384;
441	if (what_they_get < MIN_REMOTE_PACKET_SIZE16)
442	what_they_get = MIN_REMOTE_PACKET_SIZE16;
443	return what_they_get;
444	}
445
446	/* Update the size of a read/write packet. If they user wants
447	something really big then do a sanity check. */
448
449	static void
450	set_memory_packet_size (char args, struct memory_packet_config config)
451	{
452	int fixed_p = config->fixed_p;
453	long size = config->size;
454	if (args == NULL((void*)0))
455	error ("Argument required (integer, `fixed' or `limited').");
456	else if (strcmp (args, "hard") == 0
457	\|\| strcmp (args, "fixed") == 0)
458	fixed_p = 1;
459	else if (strcmp (args, "soft") == 0
460	\|\| strcmp (args, "limit") == 0)
461	fixed_p = 0;
462	else
463	{
464	char *end;
465	size = strtoul (args, &end, 0);
466	if (args == end)
467	error ("Invalid %s (bad syntax).", config->name);
468	#if 0
469	/* Instead of explicitly capping the size of a packet to
470	MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
471	instead allowed to set the size to something arbitrarily
472	large. */
473	if (size > MAX_REMOTE_PACKET_SIZE16384)
474	error ("Invalid %s (too large).", config->name);
475	#endif
476	}
477	/* Extra checks? */
478	if (fixed_p && !config->fixed_p)
479	{
480	if (! query ("The target may not be able to correctly handle a %s\n"
481	"of %ld bytes. Change the packet size? ",
482	config->name, size))
483	error ("Packet size not changed.");
484	}
485	/* Update the config. */
486	config->fixed_p = fixed_p;
487	config->size = size;
488	}
489
490	static void
491	show_memory_packet_size (struct memory_packet_config *config)
492	{
493	printf_filtered ("The %s is %ld. ", config->name, config->size);
494	if (config->fixed_p)
495	printf_filtered ("Packets are fixed at %ld bytes.\n",
496	get_memory_packet_size (config));
497	else
498	printf_filtered ("Packets are limited to %ld bytes.\n",
499	get_memory_packet_size (config));
500	}
501
502	static struct memory_packet_config memory_write_packet_config =
503	{
504	"memory-write-packet-size",
505	};
506
507	static void
508	set_memory_write_packet_size (char *args, int from_tty)
509	{
510	set_memory_packet_size (args, &memory_write_packet_config);
511	}
512
513	static void
514	show_memory_write_packet_size (char *args, int from_tty)
515	{
516	show_memory_packet_size (&memory_write_packet_config);
517	}
518
519	static long
520	get_memory_write_packet_size (void)
521	{
522	return get_memory_packet_size (&memory_write_packet_config);
523	}
524
525	static struct memory_packet_config memory_read_packet_config =
526	{
527	"memory-read-packet-size",
528	};
529
530	static void
531	set_memory_read_packet_size (char *args, int from_tty)
532	{
533	set_memory_packet_size (args, &memory_read_packet_config);
534	}
535
536	static void
537	show_memory_read_packet_size (char *args, int from_tty)
538	{
539	show_memory_packet_size (&memory_read_packet_config);
540	}
541
542	static long
543	get_memory_read_packet_size (void)
544	{
545	struct remote_state *rs = get_remote_state ();
546	long size = get_memory_packet_size (&memory_read_packet_config);
547	/* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
548	extra buffer size argument before the memory read size can be
549	increased beyond (rs->remote_packet_size). */
550	if (size > (rs->remote_packet_size))
551	size = (rs->remote_packet_size);
552	return size;
553	}
554
555
556	/* Generic configuration support for packets the stub optionally
557	supports. Allows the user to specify the use of the packet as well
558	as allowing GDB to auto-detect support in the remote stub. */
559
560	enum packet_support
561	{
562	PACKET_SUPPORT_UNKNOWN = 0,
563	PACKET_ENABLE,
564	PACKET_DISABLE
565	};
566
567	struct packet_config
568	{
569	char *name;
570	char *title;
571	enum auto_boolean detect;
572	enum packet_support support;
573	};
574
575	/* Analyze a packet's return value and update the packet config
576	accordingly. */
577
578	enum packet_result
579	{
580	PACKET_ERROR,
581	PACKET_OK,
582	PACKET_UNKNOWN
583	};
584
585	static void
586	update_packet_config (struct packet_config *config)
587	{
588	switch (config->detect)
589	{
590	case AUTO_BOOLEAN_TRUE:
591	config->support = PACKET_ENABLE;
592	break;
593	case AUTO_BOOLEAN_FALSE:
594	config->support = PACKET_DISABLE;
595	break;
596	case AUTO_BOOLEAN_AUTO:
597	config->support = PACKET_SUPPORT_UNKNOWN;
598	break;
599	}
600	}
601
602	static void
603	show_packet_config_cmd (struct packet_config *config)
604	{
605	char *support = "internal-error";
606	switch (config->support)
607	{
608	case PACKET_ENABLE:
609	support = "enabled";
610	break;
611	case PACKET_DISABLE:
612	support = "disabled";
613	break;
614	case PACKET_SUPPORT_UNKNOWN:
615	support = "unknown";
616	break;
617	}
618	switch (config->detect)
619	{
620	case AUTO_BOOLEAN_AUTO:
621	printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
622	config->name, config->title, support);
623	break;
624	case AUTO_BOOLEAN_TRUE:
625	case AUTO_BOOLEAN_FALSE:
626	printf_filtered ("Support for remote protocol `%s' (%s) packet is currently %s.\n",
627	config->name, config->title, support);
628	break;
629	}
630	}
631
632	static void
633	add_packet_config_cmd (struct packet_config *config,
634	char *name,
635	char *title,
636	cmd_sfunc_ftype *set_func,
637	cmd_sfunc_ftype *show_func,
638	struct cmd_list_element **set_remote_list,
639	struct cmd_list_element **show_remote_list,
640	int legacy)
641	{
642	struct cmd_list_element *set_cmd;
643	struct cmd_list_element *show_cmd;
644	char *set_doc;
645	char *show_doc;
646	char *help_doc;
647	char *print;
648	char *cmd_name;
649	config->name = name;
650	config->title = title;
651	config->detect = AUTO_BOOLEAN_AUTO;
652	config->support = PACKET_SUPPORT_UNKNOWN;
653	set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
654	name, title);
655	show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
656	name, title);
657	print = xstrprintf ("Current use of remote protocol `%s' (%s) is %%s",
658	name, title);
659	/* set/show TITLE-packet {auto,on,off} */
660	cmd_name = xstrprintf ("%s-packet", title);
661	add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
662	&config->detect, set_doc, show_doc,
663	"", print,
664	set_func, show_func,
665	set_remote_list, show_remote_list);
666	/* set/show remote NAME-packet {auto,on,off} -- legacy */
667	if (legacy)
668	{
669	char *legacy_name;
670	legacy_name = xstrprintf ("%s-packet", name);
671	add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
672	set_remote_list);
673	add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
674	show_remote_list);
675	}
676	}
677
678	static enum packet_result
679	packet_ok (const char buf, struct packet_config config)
680	{
681	if (buf[0] != '\0')
682	{
683	/* The stub recognized the packet request. Check that the
684	operation succeeded. */
685	switch (config->support)
686	{
687	case PACKET_SUPPORT_UNKNOWN:
688	if (remote_debug)
689	fprintf_unfiltered (gdb_stdlog,
690	"Packet %s (%s) is supported\n",
691	config->name, config->title);
692	config->support = PACKET_ENABLE;
693	break;
694	case PACKET_DISABLE:
695	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__695,
696	"packet_ok: attempt to use a disabled packet");
697	break;
698	case PACKET_ENABLE:
699	break;
700	}
701	if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
702	/* "OK" - definitly OK. */
703	return PACKET_OK;
704	if (buf[0] == 'E'
705	&& isxdigit (buf[1]) && isxdigit (buf[2])
706	&& buf[3] == '\0')
707	/* "Enn" - definitly an error. */
708	return PACKET_ERROR;
709	/* The packet may or may not be OK. Just assume it is */
710	return PACKET_OK;
711	}
712	else
713	{
714	/* The stub does not support the packet. */
715	switch (config->support)
716	{
717	case PACKET_ENABLE:
718	if (config->detect == AUTO_BOOLEAN_AUTO)
719	/* If the stub previously indicated that the packet was
720	supported then there is a protocol error.. */
721	error ("Protocol error: %s (%s) conflicting enabled responses.",
722	config->name, config->title);
723	else
724	/* The user set it wrong. */
725	error ("Enabled packet %s (%s) not recognized by stub",
726	config->name, config->title);
727	break;
728	case PACKET_SUPPORT_UNKNOWN:
729	if (remote_debug)
730	fprintf_unfiltered (gdb_stdlog,
731	"Packet %s (%s) is NOT supported\n",
732	config->name, config->title);
733	config->support = PACKET_DISABLE;
734	break;
735	case PACKET_DISABLE:
736	break;
737	}
738	return PACKET_UNKNOWN;
739	}
740	}
741
742	/* Should we try the 'vCont' (descriptive resume) request? */
743	static struct packet_config remote_protocol_vcont;
744
745	static void
746	set_remote_protocol_vcont_packet_cmd (char *args, int from_tty,
747	struct cmd_list_element *c)
748	{
749	update_packet_config (&remote_protocol_vcont);
750	}
751
752	static void
753	show_remote_protocol_vcont_packet_cmd (char *args, int from_tty,
754	struct cmd_list_element *c)
755	{
756	show_packet_config_cmd (&remote_protocol_vcont);
757	}
758
759	/* Should we try the 'qSymbol' (target symbol lookup service) request? */
760	static struct packet_config remote_protocol_qSymbol;
761
762	static void
763	set_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
764	struct cmd_list_element *c)
765	{
766	update_packet_config (&remote_protocol_qSymbol);
767	}
768
769	static void
770	show_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
771	struct cmd_list_element *c)
772	{
773	show_packet_config_cmd (&remote_protocol_qSymbol);
774	}
775
776	/* Should we try the 'P' (set register) request? */
777
778	static struct packet_config remote_protocol_P;
779
780	static void
781	set_remote_protocol_P_packet_cmd (char *args, int from_tty,
782	struct cmd_list_element *c)
783	{
784	update_packet_config (&remote_protocol_P);
785	}
786
787	static void
788	show_remote_protocol_P_packet_cmd (char *args, int from_tty,
789	struct cmd_list_element *c)
790	{
791	show_packet_config_cmd (&remote_protocol_P);
792	}
793
794	/* Should we try one of the 'Z' requests? */
795
796	enum Z_packet_type
797	{
798	Z_PACKET_SOFTWARE_BP,
799	Z_PACKET_HARDWARE_BP,
800	Z_PACKET_WRITE_WP,
801	Z_PACKET_READ_WP,
802	Z_PACKET_ACCESS_WP,
803	NR_Z_PACKET_TYPES
804	};
805
806	static struct packet_config remote_protocol_Z[NR_Z_PACKET_TYPES];
807
808	/* FIXME: Instead of having all these boiler plate functions, the
809	command callback should include a context argument. */
810
811	static void
812	set_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
813	struct cmd_list_element *c)
814	{
815	update_packet_config (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
816	}
817
818	static void
819	show_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
820	struct cmd_list_element *c)
821	{
822	show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
823	}
824
825	static void
826	set_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
827	struct cmd_list_element *c)
828	{
829	update_packet_config (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
830	}
831
832	static void
833	show_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
834	struct cmd_list_element *c)
835	{
836	show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
837	}
838
839	static void
840	set_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
841	struct cmd_list_element *c)
842	{
843	update_packet_config (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
844	}
845
846	static void
847	show_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
848	struct cmd_list_element *c)
849	{
850	show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
851	}
852
853	static void
854	set_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
855	struct cmd_list_element *c)
856	{
857	update_packet_config (&remote_protocol_Z[Z_PACKET_READ_WP]);
858	}
859
860	static void
861	show_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
862	struct cmd_list_element *c)
863	{
864	show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP]);
865	}
866
867	static void
868	set_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
869	struct cmd_list_element *c)
870	{
871	update_packet_config (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
872	}
873
874	static void
875	show_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
876	struct cmd_list_element *c)
877	{
878	show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
879	}
880
881	/* For compatibility with older distributions. Provide a ``set remote
882	Z-packet ...'' command that updates all the Z packet types. */
883
884	static enum auto_boolean remote_Z_packet_detect;
885
886	static void
887	set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
888	struct cmd_list_element *c)
889	{
890	int i;
891	for (i = 0; i < NR_Z_PACKET_TYPES; i++)
892	{
893	remote_protocol_Z[i].detect = remote_Z_packet_detect;
894	update_packet_config (&remote_protocol_Z[i]);
895	}
896	}
897
898	static void
899	show_remote_protocol_Z_packet_cmd (char *args, int from_tty,
900	struct cmd_list_element *c)
901	{
902	int i;
903	for (i = 0; i < NR_Z_PACKET_TYPES; i++)
904	{
905	show_packet_config_cmd (&remote_protocol_Z[i]);
906	}
907	}
908
909	/* Should we try the 'X' (remote binary download) packet?
910
911	This variable (available to the user via "set remote X-packet")
912	dictates whether downloads are sent in binary (via the 'X' packet).
913	We assume that the stub can, and attempt to do it. This will be
914	cleared if the stub does not understand it. This switch is still
915	needed, though in cases when the packet is supported in the stub,
916	but the connection does not allow it (i.e., 7-bit serial connection
917	only). */
918
919	static struct packet_config remote_protocol_binary_download;
920
921	/* Should we try the 'ThreadInfo' query packet?
922
923	This variable (NOT available to the user: auto-detect only!)
924	determines whether GDB will use the new, simpler "ThreadInfo"
925	query or the older, more complex syntax for thread queries.
926	This is an auto-detect variable (set to true at each connect,
927	and set to false when the target fails to recognize it). */
928
929	static int use_threadinfo_query;
930	static int use_threadextra_query;
931
932	static void
933	set_remote_protocol_binary_download_cmd (char *args,
934	int from_tty,
935	struct cmd_list_element *c)
936	{
937	update_packet_config (&remote_protocol_binary_download);
938	}
939
940	static void
941	show_remote_protocol_binary_download_cmd (char *args, int from_tty,
942	struct cmd_list_element *c)
943	{
944	show_packet_config_cmd (&remote_protocol_binary_download);
945	}
946
947	/* Should we try the 'qPart:auxv' (target auxiliary vector read) request? */
948	static struct packet_config remote_protocol_qPart_auxv;
949
950	static void
951	set_remote_protocol_qPart_auxv_packet_cmd (char *args, int from_tty,
952	struct cmd_list_element *c)
953	{
954	update_packet_config (&remote_protocol_qPart_auxv);
955	}
956
957	static void
958	show_remote_protocol_qPart_auxv_packet_cmd (char *args, int from_tty,
959	struct cmd_list_element *c)
960	{
961	show_packet_config_cmd (&remote_protocol_qPart_auxv);
962	}
963
964	static struct packet_config remote_protocol_p;
965
966	static void
967	set_remote_protocol_p_packet_cmd (char *args, int from_tty,
968	struct cmd_list_element *c)
969	{
970	update_packet_config (&remote_protocol_p);
971	}
972
973	static void
974	show_remote_protocol_p_packet_cmd (char *args, int from_tty,
975	struct cmd_list_element *c)
976	{
977	show_packet_config_cmd (&remote_protocol_p);
978	}
979
980
981
982	/* Tokens for use by the asynchronous signal handlers for SIGINT */
983	static void *sigint_remote_twice_token;
984	static void *sigint_remote_token;
985
986	/* These are pointers to hook functions that may be set in order to
987	modify resume/wait behavior for a particular architecture. */
988
989	void (*deprecated_target_resume_hook) (void);
990	void (*deprecated_target_wait_loop_hook) (void);
991
992
993
994	/* These are the threads which we last sent to the remote system.
995	-1 for all or -2 for not sent yet. */
996	static int general_thread;
997	static int continue_thread;
998
999	/* Call this function as a result of
1000	1) A halt indication (T packet) containing a thread id
1001	2) A direct query of currthread
1002	3) Successful execution of set thread
1003	*/
1004
1005	static void
1006	record_currthread (int currthread)
1007	{
1008	general_thread = currthread;
1009
1010	/* If this is a new thread, add it to GDB's thread list.
1011	If we leave it up to WFI to do this, bad things will happen. */
1012	if (!in_thread_list (pid_to_ptid (currthread)))
1013	{
1014	add_thread (pid_to_ptid (currthread));
1015	ui_out_text (uiout, "[New ");
1016	ui_out_text (uiout, target_pid_to_str (pid_to_ptid (currthread))current_target.to_pid_to_str (pid_to_ptid (currthread)));
1017	ui_out_text (uiout, "]\n");
1018	}
1019	}
1020
1021	#define MAGIC_NULL_PID42000 42000
1022
1023	static void
1024	set_thread (int th, int gen)
1025	{
1026	struct remote_state *rs = get_remote_state ();
1027	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1028	int state = gen ? general_thread : continue_thread;
1029
1030	if (state == th)
1031	return;
1032
1033	buf[0] = 'H';
1034	buf[1] = gen ? 'g' : 'c';
1035	if (th == MAGIC_NULL_PID42000)
1036	{
1037	buf[2] = '0';
1038	buf[3] = '\0';
1039	}
1040	else if (th < 0)
1041	sprintf (&buf[2], "-%x", -th);
1042	else
1043	sprintf (&buf[2], "%x", th);
1044	putpkt (buf);
1045	getpkt (buf, (rs->remote_packet_size), 0);
1046	if (gen)
1047	general_thread = th;
1048	else
1049	continue_thread = th;
1050	}
1051
1052	/* Return nonzero if the thread TH is still alive on the remote system. */
1053
1054	static int
1055	remote_thread_alive (ptid_t ptid)
1056	{
1057	int tid = PIDGET (ptid)(ptid_get_pid (ptid));
1058	char buf[16];
1059
1060	if (tid < 0)
1061	sprintf (buf, "T-%08x", -tid);
1062	else
1063	sprintf (buf, "T%08x", tid);
1064	putpkt (buf);
1065	getpkt (buf, sizeof (buf), 0);
1066	return (buf[0] == 'O' && buf[1] == 'K');
1067	}
1068
1069	/* About these extended threadlist and threadinfo packets. They are
1070	variable length packets but, the fields within them are often fixed
1071	length. They are redundent enough to send over UDP as is the
1072	remote protocol in general. There is a matching unit test module
1073	in libstub. */
1074
1075	#define OPAQUETHREADBYTES8 8
1076
1077	/* a 64 bit opaque identifier */
1078	typedef unsigned char threadref[OPAQUETHREADBYTES8];
1079
1080	/* WARNING: This threadref data structure comes from the remote O.S., libstub
1081	protocol encoding, and remote.c. it is not particularly changable */
1082
1083	/* Right now, the internal structure is int. We want it to be bigger.
1084	Plan to fix this.
1085	*/
1086
1087	typedef int gdb_threadref; /* internal GDB thread reference */
1088
1089	/* gdb_ext_thread_info is an internal GDB data structure which is
1090	equivalint to the reply of the remote threadinfo packet */
1091
1092	struct gdb_ext_thread_info
1093	{
1094	threadref threadid; /* External form of thread reference */
1095	int active; /* Has state interesting to GDB? , regs, stack */
1096	char display[256]; /* Brief state display, name, blocked/syspended */
1097	char shortname[32]; /* To be used to name threads */
1098	char more_display[256]; /* Long info, statistics, queue depth, whatever */
1099	};
1100
1101	/* The volume of remote transfers can be limited by submitting
1102	a mask containing bits specifying the desired information.
1103	Use a union of these values as the 'selection' parameter to
1104	get_thread_info. FIXME: Make these TAG names more thread specific.
1105	*/
1106
1107	#define TAG_THREADID1 1
1108	#define TAG_EXISTS2 2
1109	#define TAG_DISPLAY4 4
1110	#define TAG_THREADNAME8 8
1111	#define TAG_MOREDISPLAY16 16
1112
1113	#define BUF_THREAD_ID_SIZE(82) (OPAQUETHREADBYTES82)
1114
1115	char unpack_varlen_hex (char buff, ULONGESTunsigned long *result);
1116
1117	static char unpack_nibble (char buf, int *val);
1118
1119	static char pack_nibble (char buf, int nibble);
1120
1121	static char pack_hex_byte (char pkt, int /unsigned char / byte);
1122
1123	static char unpack_byte (char buf, int *value);
1124
1125	static char pack_int (char buf, int value);
1126
1127	static char unpack_int (char buf, int *value);
1128
1129	static char unpack_string (char src, char *dest, int length);
1130
1131	static char pack_threadid (char pkt, threadref * id);
1132
1133	static char unpack_threadid (char inbuf, threadref * id);
1134
1135	void int_to_threadref (threadref * id, int value);
1136
1137	static int threadref_to_int (threadref * ref);
1138
1139	static void copy_threadref (threadref * dest, threadref * src);
1140
1141	static int threadmatch (threadref * dest, threadref * src);
1142
1143	static char pack_threadinfo_request (char pkt, int mode, threadref * id);
1144
1145	static int remote_unpack_thread_info_response (char *pkt,
1146	threadref * expectedref,
1147	struct gdb_ext_thread_info
1148	*info);
1149
1150
1151	static int remote_get_threadinfo (threadref * threadid, int fieldset, /TAG mask /
1152	struct gdb_ext_thread_info *info);
1153
1154	static char pack_threadlist_request (char pkt, int startflag,
1155	int threadcount,
1156	threadref * nextthread);
1157
1158	static int parse_threadlist_response (char *pkt,
1159	int result_limit,
1160	threadref * original_echo,
1161	threadref * resultlist, int *doneflag);
1162
1163	static int remote_get_threadlist (int startflag,
1164	threadref * nextthread,
1165	int result_limit,
1166	int *done,
1167	int result_count, threadref threadlist);
1168
1169	typedef int (rmt_thread_action) (threadref ref, void *context);
1170
1171	static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1172	void *context, int looplimit);
1173
1174	static int remote_newthread_step (threadref * ref, void *context);
1175
1176	/* encode 64 bits in 16 chars of hex */
1177
1178	static const char hexchars[] = "0123456789abcdef";
1179
1180	static int
1181	ishex (int ch, int *val)
1182	{
1183	if ((ch >= 'a') && (ch <= 'f'))
1184	{
1185	*val = ch - 'a' + 10;
1186	return 1;
1187	}
1188	if ((ch >= 'A') && (ch <= 'F'))
1189	{
1190	*val = ch - 'A' + 10;
1191	return 1;
1192	}
1193	if ((ch >= '0') && (ch <= '9'))
1194	{
1195	*val = ch - '0';
1196	return 1;
1197	}
1198	return 0;
1199	}
1200
1201	static int
1202	stubhex (int ch)
1203	{
1204	if (ch >= 'a' && ch <= 'f')
1205	return ch - 'a' + 10;
1206	if (ch >= '0' && ch <= '9')
1207	return ch - '0';
1208	if (ch >= 'A' && ch <= 'F')
1209	return ch - 'A' + 10;
1210	return -1;
1211	}
1212
1213	static int
1214	stub_unpack_int (char *buff, int fieldlength)
1215	{
1216	int nibble;
1217	int retval = 0;
1218
1219	while (fieldlength)
1220	{
1221	nibble = stubhex (*buff++);
1222	retval \|= nibble;
1223	fieldlength--;
1224	if (fieldlength)
1225	retval = retval << 4;
1226	}
1227	return retval;
1228	}
1229
1230	char *
1231	unpack_varlen_hex (char buff, / packet to parse */
1232	ULONGESTunsigned long *result)
1233	{
1234	int nibble;
1235	int retval = 0;
1236
1237	while (ishex (*buff, &nibble))
1238	{
1239	buff++;
1240	retval = retval << 4;
1241	retval \|= nibble & 0x0f;
1242	}
1243	*result = retval;
1244	return buff;
1245	}
1246
1247	static char *
1248	unpack_nibble (char buf, int val)
1249	{
1250	ishex (*buf++, val);
1251	return buf;
1252	}
1253
1254	static char *
1255	pack_nibble (char *buf, int nibble)
1256	{
1257	*buf++ = hexchars[(nibble & 0x0f)];
1258	return buf;
1259	}
1260
1261	static char *
1262	pack_hex_byte (char *pkt, int byte)
1263	{
1264	*pkt++ = hexchars[(byte >> 4) & 0xf];
1265	*pkt++ = hexchars[(byte & 0xf)];
1266	return pkt;
1267	}
1268
1269	static char *
1270	unpack_byte (char buf, int value)
1271	{
1272	*value = stub_unpack_int (buf, 2);
1273	return buf + 2;
1274	}
1275
1276	static char *
1277	pack_int (char *buf, int value)
1278	{
1279	buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1280	buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1281	buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1282	buf = pack_hex_byte (buf, (value & 0xff));
1283	return buf;
1284	}
1285
1286	static char *
1287	unpack_int (char buf, int value)
1288	{
1289	*value = stub_unpack_int (buf, 8);
1290	return buf + 8;
1291	}
1292
1293	#if 0 /* currently unused, uncomment when needed */
1294	static char pack_string (char pkt, char *string);
1295
1296	static char *
1297	pack_string (char pkt, char string)
1298	{
1299	char ch;
1300	int len;
1301
1302	len = strlen (string);
1303	if (len > 200)
1304	len = 200; /* Bigger than most GDB packets, junk??? */
1305	pkt = pack_hex_byte (pkt, len);
1306	while (len-- > 0)
1307	{
1308	ch = *string++;
1309	if ((ch == '\0') \|\| (ch == '#'))
1310	ch = ''; / Protect encapsulation */
1311	*pkt++ = ch;
1312	}
1313	return pkt;
1314	}
1315	#endif /* 0 (unused) */
1316
1317	static char *
1318	unpack_string (char src, char dest, int length)
1319	{
1320	while (length--)
1321	dest++ = src++;
1322	*dest = '\0';
1323	return src;
1324	}
1325
1326	static char *
1327	pack_threadid (char pkt, threadref id)
1328	{
1329	char *limit;
1330	unsigned char *altid;
1331
1332	altid = (unsigned char *) id;
1333	limit = pkt + BUF_THREAD_ID_SIZE(8*2);
1334	while (pkt < limit)
1335	pkt = pack_hex_byte (pkt, *altid++);
1336	return pkt;
1337	}
1338
1339
1340	static char *
1341	unpack_threadid (char inbuf, threadref id)
1342	{
1343	char *altref;
1344	char limit = inbuf + BUF_THREAD_ID_SIZE(82);
1345	int x, y;
1346
1347	altref = (char *) id;
1348
1349	while (inbuf < limit)
1350	{
1351	x = stubhex (*inbuf++);
1352	y = stubhex (*inbuf++);
1353	*altref++ = (x << 4) \| y;
1354	}
1355	return inbuf;
1356	}
1357
1358	/* Externally, threadrefs are 64 bits but internally, they are still
1359	ints. This is due to a mismatch of specifications. We would like
1360	to use 64bit thread references internally. This is an adapter
1361	function. */
1362
1363	void
1364	int_to_threadref (threadref *id, int value)
1365	{
1366	unsigned char *scan;
1367
1368	scan = (unsigned char *) id;
1369	{
1370	int i = 4;
1371	while (i--)
1372	*scan++ = 0;
1373	}
1374	*scan++ = (value >> 24) & 0xff;
1375	*scan++ = (value >> 16) & 0xff;
1376	*scan++ = (value >> 8) & 0xff;
1377	*scan++ = (value & 0xff);
1378	}
1379
1380	static int
1381	threadref_to_int (threadref *ref)
1382	{
1383	int i, value = 0;
1384	unsigned char *scan;
1385
1386	scan = (char *) ref;
1387	scan += 4;
1388	i = 4;
1389	while (i-- > 0)
1390	value = (value << 8) \| ((*scan++) & 0xff);
1391	return value;
1392	}
1393
1394	static void
1395	copy_threadref (threadref dest, threadref src)
1396	{
1397	int i;
1398	unsigned char csrc, cdest;
1399
1400	csrc = (unsigned char *) src;
1401	cdest = (unsigned char *) dest;
1402	i = 8;
1403	while (i--)
1404	cdest++ = csrc++;
1405	}
1406
1407	static int
1408	threadmatch (threadref dest, threadref src)
1409	{
1410	/* things are broken right now, so just assume we got a match */
1411	#if 0
1412	unsigned char srcp, destp;
1413	int i, result;
1414	srcp = (char *) src;
1415	destp = (char *) dest;
1416
1417	result = 1;
1418	while (i-- > 0)
1419	result &= (srcp++ == destp++) ? 1 : 0;
1420	return result;
1421	#endif
1422	return 1;
1423	}
1424
1425	/*
1426	threadid:1, # always request threadid
1427	context_exists:2,
1428	display:4,
1429	unique_name:8,
1430	more_display:16
1431	*/
1432
1433	/* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1434
1435	static char *
1436	pack_threadinfo_request (char pkt, int mode, threadref id)
1437	{
1438	pkt++ = 'q'; / Info Query */
1439	pkt++ = 'P'; / process or thread info */
1440	pkt = pack_int (pkt, mode); /* mode */
1441	pkt = pack_threadid (pkt, id); /* threadid */
1442	pkt = '\0'; / terminate */
1443	return pkt;
1444	}
1445
1446	/* These values tag the fields in a thread info response packet */
1447	/* Tagging the fields allows us to request specific fields and to
1448	add more fields as time goes by */
1449
1450	#define TAG_THREADID1 1 /* Echo the thread identifier */
1451	#define TAG_EXISTS2 2 /* Is this process defined enough to
1452	fetch registers and its stack */
1453	#define TAG_DISPLAY4 4 /* A short thing maybe to put on a window */
1454	#define TAG_THREADNAME8 8 /* string, maps 1-to-1 with a thread is */
1455	#define TAG_MOREDISPLAY16 16 /* Whatever the kernel wants to say about
1456	the process */
1457
1458	static int
1459	remote_unpack_thread_info_response (char pkt, threadref expectedref,
1460	struct gdb_ext_thread_info *info)
1461	{
1462	struct remote_state *rs = get_remote_state ();
1463	int mask, length;
1464	unsigned int tag;
1465	threadref ref;
1466	char limit = pkt + (rs->remote_packet_size); / plausable parsing limit */
1467	int retval = 1;
1468
1469	/* info->threadid = 0; FIXME: implement zero_threadref */
1470	info->active = 0;
1471	info->display[0] = '\0';
1472	info->shortname[0] = '\0';
1473	info->more_display[0] = '\0';
1474
1475	/* Assume the characters indicating the packet type have been stripped */
1476	pkt = unpack_int (pkt, &mask); /* arg mask */
1477	pkt = unpack_threadid (pkt, &ref);
1478
1479	if (mask == 0)
1480	warning ("Incomplete response to threadinfo request\n");
1481	if (!threadmatch (&ref, expectedref))
1482	{ /* This is an answer to a different request */
1483	warning ("ERROR RMT Thread info mismatch\n");
1484	return 0;
1485	}
1486	copy_threadref (&info->threadid, &ref);
1487
1488	/* Loop on tagged fields , try to bail if somthing goes wrong */
1489
1490	while ((pkt < limit) && mask && pkt) / packets are terminated with nulls */
1491	{
1492	pkt = unpack_int (pkt, &tag); /* tag */
1493	pkt = unpack_byte (pkt, &length); /* length */
1494	if (!(tag & mask)) /* tags out of synch with mask */
1495	{
1496	warning ("ERROR RMT: threadinfo tag mismatch\n");
1497	retval = 0;
1498	break;
1499	}
1500	if (tag == TAG_THREADID1)
1501	{
1502	if (length != 16)
1503	{
1504	warning ("ERROR RMT: length of threadid is not 16\n");
1505	retval = 0;
1506	break;
1507	}
1508	pkt = unpack_threadid (pkt, &ref);
1509	mask = mask & ~TAG_THREADID1;
1510	continue;
1511	}
1512	if (tag == TAG_EXISTS2)
1513	{
1514	info->active = stub_unpack_int (pkt, length);
1515	pkt += length;
1516	mask = mask & ~(TAG_EXISTS2);
1517	if (length > 8)
1518	{
1519	warning ("ERROR RMT: 'exists' length too long\n");
1520	retval = 0;
1521	break;
1522	}
1523	continue;
1524	}
1525	if (tag == TAG_THREADNAME8)
1526	{
1527	pkt = unpack_string (pkt, &info->shortname[0], length);
1528	mask = mask & ~TAG_THREADNAME8;
1529	continue;
1530	}
1531	if (tag == TAG_DISPLAY4)
1532	{
1533	pkt = unpack_string (pkt, &info->display[0], length);
1534	mask = mask & ~TAG_DISPLAY4;
1535	continue;
1536	}
1537	if (tag == TAG_MOREDISPLAY16)
1538	{
1539	pkt = unpack_string (pkt, &info->more_display[0], length);
1540	mask = mask & ~TAG_MOREDISPLAY16;
1541	continue;
1542	}
1543	warning ("ERROR RMT: unknown thread info tag\n");
1544	break; /* Not a tag we know about */
1545	}
1546	return retval;
1547	}
1548
1549	static int
1550	remote_get_threadinfo (threadref threadid, int fieldset, / TAG mask */
1551	struct gdb_ext_thread_info *info)
1552	{
1553	struct remote_state *rs = get_remote_state ();
1554	int result;
1555	char *threadinfo_pkt = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1556
1557	pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
1558	putpkt (threadinfo_pkt);
1559	getpkt (threadinfo_pkt, (rs->remote_packet_size), 0);
1560	result = remote_unpack_thread_info_response (threadinfo_pkt + 2, threadid,
1561	info);
1562	return result;
1563	}
1564
1565	/* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1566
1567	static char *
1568	pack_threadlist_request (char *pkt, int startflag, int threadcount,
1569	threadref *nextthread)
1570	{
1571	pkt++ = 'q'; / info query packet */
1572	pkt++ = 'L'; / Process LIST or threadLIST request */
1573	pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1574	pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1575	pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1576	*pkt = '\0';
1577	return pkt;
1578	}
1579
1580	/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1581
1582	static int
1583	parse_threadlist_response (char *pkt, int result_limit,
1584	threadref original_echo, threadref resultlist,
1585	int *doneflag)
1586	{
1587	struct remote_state *rs = get_remote_state ();
1588	char *limit;
1589	int count, resultcount, done;
1590
1591	resultcount = 0;
1592	/* Assume the 'q' and 'M chars have been stripped. */
1593	limit = pkt + ((rs->remote_packet_size) - BUF_THREAD_ID_SIZE(82)); / done parse past here */
1594	pkt = unpack_byte (pkt, &count); /* count field */
1595	pkt = unpack_nibble (pkt, &done);
1596	/* The first threadid is the argument threadid. */
1597	pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1598	while ((count-- > 0) && (pkt < limit))
1599	{
1600	pkt = unpack_threadid (pkt, resultlist++);
1601	if (resultcount++ >= result_limit)
1602	break;
1603	}
1604	if (doneflag)
1605	*doneflag = done;
1606	return resultcount;
1607	}
1608
1609	static int
1610	remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
1611	int done, int result_count, threadref *threadlist)
1612	{
1613	struct remote_state *rs = get_remote_state ();
1614	static threadref echo_nextthread;
1615	char *threadlist_packet = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1616	char *t_response = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1617	int result = 1;
1618
1619	/* Trancate result limit to be smaller than the packet size */
1620	if ((((result_limit + 1) * BUF_THREAD_ID_SIZE(8*2)) + 10) >= (rs->remote_packet_size))
1621	result_limit = ((rs->remote_packet_size) / BUF_THREAD_ID_SIZE(8*2)) - 2;
1622
1623	pack_threadlist_request (threadlist_packet,
1624	startflag, result_limit, nextthread);
1625	putpkt (threadlist_packet);
1626	getpkt (t_response, (rs->remote_packet_size), 0);
1627
1628	*result_count =
1629	parse_threadlist_response (t_response + 2, result_limit, &echo_nextthread,
1630	threadlist, done);
1631
1632	if (!threadmatch (&echo_nextthread, nextthread))
1633	{
1634	/* FIXME: This is a good reason to drop the packet */
1635	/* Possably, there is a duplicate response */
1636	/* Possabilities :
1637	retransmit immediatly - race conditions
1638	retransmit after timeout - yes
1639	exit
1640	wait for packet, then exit
1641	*/
1642	warning ("HMM: threadlist did not echo arg thread, dropping it\n");
1643	return 0; /* I choose simply exiting */
1644	}
1645	if (*result_count <= 0)
1646	{
1647	if (*done != 1)
1648	{
1649	warning ("RMT ERROR : failed to get remote thread list\n");
1650	result = 0;
1651	}
1652	return result; /* break; */
1653	}
1654	if (*result_count > result_limit)
1655	{
1656	*result_count = 0;
1657	warning ("RMT ERROR: threadlist response longer than requested\n");
1658	return 0;
1659	}
1660	return result;
1661	}
1662
1663	/* This is the interface between remote and threads, remotes upper interface */
1664
1665	/* remote_find_new_threads retrieves the thread list and for each
1666	thread in the list, looks up the thread in GDB's internal list,
1667	ading the thread if it does not already exist. This involves
1668	getting partial thread lists from the remote target so, polling the
1669	quit_flag is required. */
1670
1671
1672	/* About this many threadisds fit in a packet. */
1673
1674	#define MAXTHREADLISTRESULTS32 32
1675
1676	static int
1677	remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
1678	int looplimit)
1679	{
1680	int done, i, result_count;
1681	int startflag = 1;
1682	int result = 1;
1683	int loopcount = 0;
1684	static threadref nextthread;
1685	static threadref resultthreadlist[MAXTHREADLISTRESULTS32];
1686
1687	done = 0;
1688	while (!done)
1689	{
1690	if (loopcount++ > looplimit)
1691	{
1692	result = 0;
1693	warning ("Remote fetch threadlist -infinite loop-\n");
1694	break;
1695	}
1696	if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS32,
1697	&done, &result_count, resultthreadlist))
1698	{
1699	result = 0;
1700	break;
1701	}
1702	/* clear for later iterations */
1703	startflag = 0;
1704	/* Setup to resume next batch of thread references, set nextthread. */
1705	if (result_count >= 1)
1706	copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1707	i = 0;
1708	while (result_count--)
1709	if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1710	break;
1711	}
1712	return result;
1713	}
1714
1715	static int
1716	remote_newthread_step (threadref ref, void context)
1717	{
1718	ptid_t ptid;
1719
1720	ptid = pid_to_ptid (threadref_to_int (ref));
1721
1722	if (!in_thread_list (ptid))
1723	add_thread (ptid);
1724	return 1; /* continue iterator */
1725	}
1726
1727	#define CRAZY_MAX_THREADS1000 1000
1728
1729	static ptid_t
1730	remote_current_thread (ptid_t oldpid)
1731	{
1732	struct remote_state *rs = get_remote_state ();
1733	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1734
1735	putpkt ("qC");
1736	getpkt (buf, (rs->remote_packet_size), 0);
1737	if (buf[0] == 'Q' && buf[1] == 'C')
1738	return pid_to_ptid (strtol (&buf[2], NULL((void*)0), 16));
1739	else
1740	return oldpid;
1741	}
1742
1743	/* Find new threads for info threads command.
1744	* Original version, using John Metzler's thread protocol.
1745	*/
1746
1747	static void
1748	remote_find_new_threads (void)
1749	{
1750	remote_threadlist_iterator (remote_newthread_step, 0,
1751	CRAZY_MAX_THREADS1000);
1752	if (PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)) == MAGIC_NULL_PID42000) /* ack ack ack */
1753	inferior_ptid = remote_current_thread (inferior_ptid);
1754	}
1755
1756	/*
1757	* Find all threads for info threads command.
1758	* Uses new thread protocol contributed by Cisco.
1759	* Falls back and attempts to use the older method (above)
1760	* if the target doesn't respond to the new method.
1761	*/
1762
1763	static void
1764	remote_threads_info (void)
1765	{
1766	struct remote_state *rs = get_remote_state ();
1767	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1768	char *bufp;
1769	int tid;
1770
1771	if (remote_desc == 0) /* paranoia */
1772	error ("Command can only be used when connected to the remote target.");
1773
1774	if (use_threadinfo_query)
1775	{
1776	putpkt ("qfThreadInfo");
1777	bufp = buf;
1778	getpkt (bufp, (rs->remote_packet_size), 0);
1779	if (bufp[0] != '\0') /* q packet recognized */
1780	{
1781	while (bufp++ == 'm') / reply contains one or more TID */
1782	{
1783	do
1784	{
1785	tid = strtol (bufp, &bufp, 16);
1786	if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
1787	add_thread (pid_to_ptid (tid));
1788	}
1789	while (bufp++ == ','); / comma-separated list */
1790	putpkt ("qsThreadInfo");
1791	bufp = buf;
1792	getpkt (bufp, (rs->remote_packet_size), 0);
1793	}
1794	return; /* done */
1795	}
1796	}
1797
1798	/* Else fall back to old method based on jmetzler protocol. */
1799	use_threadinfo_query = 0;
1800	remote_find_new_threads ();
1801	return;
1802	}
1803
1804	/*
1805	* Collect a descriptive string about the given thread.
1806	* The target may say anything it wants to about the thread
1807	* (typically info about its blocked / runnable state, name, etc.).
1808	* This string will appear in the info threads display.
1809	*
1810	* Optional: targets are not required to implement this function.
1811	*/
1812
1813	static char *
1814	remote_threads_extra_info (struct thread_info *tp)
1815	{
1816	struct remote_state *rs = get_remote_state ();
1817	int result;
1818	int set;
1819	threadref id;
1820	struct gdb_ext_thread_info threadinfo;
1821	static char display_buf[100]; /* arbitrary... */
1822	char *bufp = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1823	int n = 0; /* position in display_buf */
1824
1825	if (remote_desc == 0) /* paranoia */
1826	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__1826,
1827	"remote_threads_extra_info");
1828
1829	if (use_threadextra_query)
1830	{
1831	sprintf (bufp, "qThreadExtraInfo,%x", PIDGET (tp->ptid)(ptid_get_pid (tp->ptid)));
1832	putpkt (bufp);
1833	getpkt (bufp, (rs->remote_packet_size), 0);
1834	if (bufp[0] != 0)
1835	{
1836	n = min (strlen (bufp) / 2, sizeof (display_buf))((strlen (bufp) / 2) < (sizeof (display_buf)) ? (strlen (bufp ) / 2) : (sizeof (display_buf)));
1837	result = hex2bin (bufp, display_buf, n);
1838	display_buf [result] = '\0';
1839	return display_buf;
1840	}
1841	}
1842
1843	/* If the above query fails, fall back to the old method. */
1844	use_threadextra_query = 0;
1845	set = TAG_THREADID1 \| TAG_EXISTS2 \| TAG_THREADNAME8
1846	\| TAG_MOREDISPLAY16 \| TAG_DISPLAY4;
1847	int_to_threadref (&id, PIDGET (tp->ptid)(ptid_get_pid (tp->ptid)));
1848	if (remote_get_threadinfo (&id, set, &threadinfo))
1849	if (threadinfo.active)
1850	{
1851	if (*threadinfo.shortname)
1852	n += sprintf(&display_buf[0], " Name: %s,", threadinfo.shortname);
1853	if (*threadinfo.display)
1854	n += sprintf(&display_buf[n], " State: %s,", threadinfo.display);
1855	if (*threadinfo.more_display)
1856	n += sprintf(&display_buf[n], " Priority: %s",
1857	threadinfo.more_display);
1858
1859	if (n > 0)
1860	{
1861	/* for purely cosmetic reasons, clear up trailing commas */
1862	if (',' == display_buf[n-1])
1863	display_buf[n-1] = ' ';
1864	return display_buf;
1865	}
1866	}
1867	return NULL((void*)0);
1868	}
1869
1870
1871
1872	/* Restart the remote side; this is an extended protocol operation. */
1873
1874	static void
1875	extended_remote_restart (void)
1876	{
1877	struct remote_state *rs = get_remote_state ();
1878	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1879
1880	/* Send the restart command; for reasons I don't understand the
1881	remote side really expects a number after the "R". */
1882	buf[0] = 'R';
1883	sprintf (&buf[1], "%x", 0);
1884	putpkt (buf);
1885
1886	/* Now query for status so this looks just like we restarted
1887	gdbserver from scratch. */
1888	putpkt ("?");
1889	getpkt (buf, (rs->remote_packet_size), 0);
1890	}
1891
1892	/* Clean up connection to a remote debugger. */
1893
1894	static void
1895	remote_close (int quitting)
1896	{
1897	if (remote_desc)
1898	serial_close (remote_desc);
1899	remote_desc = NULL((void*)0);
1900	}
1901
1902	/* Query the remote side for the text, data and bss offsets. */
1903
1904	static void
1905	get_offsets (void)
1906	{
1907	struct remote_state *rs = get_remote_state ();
1908	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
1909	char *ptr;
1910	int lose;
1911	CORE_ADDR text_addr, data_addr, bss_addr;
1912	struct section_offsets *offs;
1913
1914	putpkt ("qOffsets");
1915
1916	getpkt (buf, (rs->remote_packet_size), 0);
1917
1918	if (buf[0] == '\000')
1919	return; /* Return silently. Stub doesn't support
1920	this command. */
1921	if (buf[0] == 'E')
1922	{
1923	warning ("Remote failure reply: %s", buf);
1924	return;
1925	}
1926
1927	/* Pick up each field in turn. This used to be done with scanf, but
1928	scanf will make trouble if CORE_ADDR size doesn't match
1929	conversion directives correctly. The following code will work
1930	with any size of CORE_ADDR. */
1931	text_addr = data_addr = bss_addr = 0;
1932	ptr = buf;
1933	lose = 0;
1934
1935	if (strncmp (ptr, "Text=", 5) == 0)
1936	{
1937	ptr += 5;
1938	/* Don't use strtol, could lose on big values. */
1939	while (ptr && ptr != ';')
1940	text_addr = (text_addr << 4) + fromhex (*ptr++);
1941	}
1942	else
1943	lose = 1;
1944
1945	if (!lose && strncmp (ptr, ";Data=", 6) == 0)
1946	{
1947	ptr += 6;
1948	while (ptr && ptr != ';')
1949	data_addr = (data_addr << 4) + fromhex (*ptr++);
1950	}
1951	else
1952	lose = 1;
1953
1954	if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
1955	{
1956	ptr += 5;
1957	while (ptr && ptr != ';')
1958	bss_addr = (bss_addr << 4) + fromhex (*ptr++);
1959	}
1960	else
1961	lose = 1;
1962
1963	if (lose)
1964	error ("Malformed response to offset query, %s", buf);
1965
1966	if (symfile_objfile == NULL((void*)0))
1967	return;
1968
1969	offs = ((struct section_offsets *)
1970	alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections))__builtin_alloca((sizeof (struct section_offsets) + sizeof (( (struct section_offsets ) 0)->offsets) ((symfile_objfile ->num_sections)-1))));
1971	memcpy (offs, symfile_objfile->section_offsets,
1972	SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)(sizeof (struct section_offsets) + sizeof (((struct section_offsets ) 0)->offsets) ((symfile_objfile->num_sections)-1)));
1973
1974	offs->offsets[SECT_OFF_TEXT (symfile_objfile)((symfile_objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c", 1974, "sect_index_text not initialized" ), -1) : symfile_objfile->sect_index_text)] = text_addr;
1975
1976	/* This is a temporary kludge to force data and bss to use the same offsets
1977	because that's what nlmconv does now. The real solution requires changes
1978	to the stub and remote.c that I don't have time to do right now. */
1979
1980	offs->offsets[SECT_OFF_DATA (symfile_objfile)((symfile_objfile->sect_index_data == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c", 1980, "sect_index_data not initialized" ), -1) : symfile_objfile->sect_index_data)] = data_addr;
1981	offs->offsets[SECT_OFF_BSS (symfile_objfile)(symfile_objfile)->sect_index_bss] = data_addr;
1982
1983	objfile_relocate (symfile_objfile, offs);
1984	}
1985
1986	/* Stub for catch_errors. */
1987
1988	static int
1989	remote_start_remote_dummy (struct ui_out uiout, void dummy)
1990	{
1991	start_remote (); /* Initialize gdb process mechanisms */
1992	/* NOTE: Return something >=0. A -ve value is reserved for
1993	catch_exceptions. */
1994	return 1;
1995	}
1996
1997	static int
1998	remote_start_remote (struct ui_out uiout, void dummy)
1999	{
2000	immediate_quit++; /* Allow user to interrupt it */
2001
2002	/* Ack any packet which the remote side has already sent. */
2003	serial_write (remote_desc, "+", 1);
2004
2005	/* Let the stub know that we want it to return the thread. */
2006	set_thread (-1, 0);
2007
2008	inferior_ptid = remote_current_thread (inferior_ptid);
2009
2010	get_offsets (); /* Get text, data & bss offsets */
2011
2012	putpkt ("?"); /* initiate a query from remote machine */
2013	immediate_quit--;
2014
2015	/* NOTE: See comment above in remote_start_remote_dummy(). This
2016	function returns something >=0. */
2017	return remote_start_remote_dummy (uiout, dummy);
2018	}
2019
2020	/* Open a connection to a remote debugger.
2021	NAME is the filename used for communication. */
2022
2023	static void
2024	remote_open (char *name, int from_tty)
2025	{
2026	remote_open_1 (name, from_tty, &remote_ops, 0, 0);
2027	}
2028
2029	/* Just like remote_open, but with asynchronous support. */
2030	static void
2031	remote_async_open (char *name, int from_tty)
2032	{
2033	remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2034	}
2035
2036	/* Open a connection to a remote debugger using the extended
2037	remote gdb protocol. NAME is the filename used for communication. */
2038
2039	static void
2040	extended_remote_open (char *name, int from_tty)
2041	{
2042	remote_open_1 (name, from_tty, &extended_remote_ops, 1 /extended_p /,
2043	0 /* async_p */);
2044	}
2045
2046	/* Just like extended_remote_open, but with asynchronous support. */
2047	static void
2048	extended_remote_async_open (char *name, int from_tty)
2049	{
2050	remote_open_1 (name, from_tty, &extended_async_remote_ops,
2051	1 /extended_p /, 1 /* async_p */);
2052	}
2053
2054	/* Generic code for opening a connection to a remote target. */
2055
2056	static void
2057	init_all_packet_configs (void)
2058	{
2059	int i;
2060	update_packet_config (&remote_protocol_P);
2061	update_packet_config (&remote_protocol_p);
2062	update_packet_config (&remote_protocol_qSymbol);
2063	update_packet_config (&remote_protocol_vcont);
2064	for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2065	update_packet_config (&remote_protocol_Z[i]);
2066	/* Force remote_write_bytes to check whether target supports binary
2067	downloading. */
2068	update_packet_config (&remote_protocol_binary_download);
2069	update_packet_config (&remote_protocol_qPart_auxv);
2070	}
2071
2072	/* Symbol look-up. */
2073
2074	static void
2075	remote_check_symbols (struct objfile *objfile)
2076	{
2077	struct remote_state *rs = get_remote_state ();
2078	char msg, reply, *tmp;
2079	struct minimal_symbol *sym;
2080	int end;
2081
2082	if (remote_protocol_qSymbol.support == PACKET_DISABLE)
2083	return;
2084
2085	msg = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2086	reply = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2087
2088	/* Invite target to request symbol lookups. */
2089
2090	putpkt ("qSymbol::");
2091	getpkt (reply, (rs->remote_packet_size), 0);
2092	packet_ok (reply, &remote_protocol_qSymbol);
2093
2094	while (strncmp (reply, "qSymbol:", 8) == 0)
2095	{
2096	tmp = &reply[8];
2097	end = hex2bin (tmp, msg, strlen (tmp) / 2);
2098	msg[end] = '\0';
2099	sym = lookup_minimal_symbol (msg, NULL((void)0), NULL((void)0));
2100	if (sym == NULL((void*)0))
2101	sprintf (msg, "qSymbol::%s", &reply[8]);
2102	else
2103	sprintf (msg, "qSymbol:%s:%s",
2104	paddr_nz (SYMBOL_VALUE_ADDRESS (sym)(sym)->ginfo.value.address),
2105	&reply[8]);
2106	putpkt (msg);
2107	getpkt (reply, (rs->remote_packet_size), 0);
2108	}
2109	}
2110
2111	static struct serial *
2112	remote_serial_open (char *name)
2113	{
2114	static int udp_warning = 0;
2115
2116	/* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2117	of in ser-tcp.c, because it is the remote protocol assuming that the
2118	serial connection is reliable and not the serial connection promising
2119	to be. */
2120	if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2121	{
2122	warning ("The remote protocol may be unreliable over UDP.");
2123	warning ("Some events may be lost, rendering further debugging "
2124	"impossible.");
2125	udp_warning = 1;
2126	}
2127
2128	return serial_open (name);
2129	}
2130
2131	static void
2132	remote_open_1 (char name, int from_tty, struct target_ops target,
2133	int extended_p, int async_p)
2134	{
2135	int ex;
2136	struct remote_state *rs = get_remote_state ();
2137	if (name == 0)
2138	error ("To open a remote debug connection, you need to specify what\n"
2139	"serial device is attached to the remote system\n"
2140	"(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
2141
2142	/* See FIXME above */
2143	if (!async_p)
2144	wait_forever_enabled_p = 1;
2145
2146	reopen_exec_file ();
2147	reread_symbols ();
2148
2149	target_preopen (from_tty);
2150
2151	unpush_target (target);
2152
2153	remote_desc = remote_serial_open (name);
2154	if (!remote_desc)
2155	perror_with_name (name);
2156
2157	if (baud_rate != -1)
2158	{
2159	if (serial_setbaudrate (remote_desc, baud_rate))
2160	{
2161	/* The requested speed could not be set. Error out to
2162	top level after closing remote_desc. Take care to
2163	set remote_desc to NULL to avoid closing remote_desc
2164	more than once. */
2165	serial_close (remote_desc);
2166	remote_desc = NULL((void*)0);
2167	perror_with_name (name);
2168	}
2169	}
2170
2171	serial_raw (remote_desc);
2172
2173	/* If there is something sitting in the buffer we might take it as a
2174	response to a command, which would be bad. */
2175	serial_flush_input (remote_desc);
2176
2177	if (from_tty)
2178	{
2179	puts_filtered ("Remote debugging using ");
2180	puts_filtered (name);
2181	puts_filtered ("\n");
2182	}
2183	push_target (target); /* Switch to using remote target now */
2184
2185	init_all_packet_configs ();
2186
2187	general_thread = -2;
2188	continue_thread = -2;
2189
2190	/* Probe for ability to use "ThreadInfo" query, as required. */
2191	use_threadinfo_query = 1;
2192	use_threadextra_query = 1;
2193
2194	/* Without this, some commands which require an active target (such
2195	as kill) won't work. This variable serves (at least) double duty
2196	as both the pid of the target process (if it has such), and as a
2197	flag indicating that a target is active. These functions should
2198	be split out into seperate variables, especially since GDB will
2199	someday have a notion of debugging several processes. */
2200
2201	inferior_ptid = pid_to_ptid (MAGIC_NULL_PID42000);
2202
2203	if (async_p)
2204	{
2205	/* With this target we start out by owning the terminal. */
2206	remote_async_terminal_ours_p = 1;
2207
2208	/* FIXME: cagney/1999-09-23: During the initial connection it is
2209	assumed that the target is already ready and able to respond to
2210	requests. Unfortunately remote_start_remote() eventually calls
2211	wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2212	around this. Eventually a mechanism that allows
2213	wait_for_inferior() to expect/get timeouts will be
2214	implemented. */
2215	wait_forever_enabled_p = 0;
2216	}
2217
2218	#ifdef SOLIB_CREATE_INFERIOR_HOOK
2219	/* First delete any symbols previously loaded from shared libraries. */
2220	no_shared_libraries (NULL((void*)0), 0);
2221	#endif
2222
2223	/* Start the remote connection. If error() or QUIT, discard this
2224	target (we'd otherwise be in an inconsistent state) and then
2225	propogate the error on up the exception chain. This ensures that
2226	the caller doesn't stumble along blindly assuming that the
2227	function succeeded. The CLI doesn't have this problem but other
2228	UI's, such as MI do.
2229
2230	FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2231	this function should return an error indication letting the
2232	caller restore the previous state. Unfortunately the command
2233	``target remote'' is directly wired to this function making that
2234	impossible. On a positive note, the CLI side of this problem has
2235	been fixed - the function set_cmd_context() makes it possible for
2236	all the ``target ....'' commands to share a common callback
2237	function. See cli-dump.c. */
2238	ex = catch_exceptions (uiout,
2239	remote_start_remote, NULL((void*)0),
2240	"Couldn't establish connection to remote"
2241	" target\n",
2242	RETURN_MASK_ALL((1 << (int)(-RETURN_QUIT)) \| (1 << (int)(-RETURN_ERROR ))));
2243	if (ex < 0)
2244	{
2245	pop_target ();
2246	if (async_p)
2247	wait_forever_enabled_p = 1;
2248	throw_exception (ex);
2249	}
2250
2251	if (async_p)
2252	wait_forever_enabled_p = 1;
2253
2254	if (extended_p)
2255	{
2256	/* Tell the remote that we are using the extended protocol. */
2257	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2258	putpkt ("!");
2259	getpkt (buf, (rs->remote_packet_size), 0);
2260	}
2261	#ifdef SOLIB_CREATE_INFERIOR_HOOK
2262	/* FIXME: need a master target_open vector from which all
2263	remote_opens can be called, so that stuff like this can
2264	go there. Failing that, the following code must be copied
2265	to the open function for any remote target that wants to
2266	support svr4 shared libraries. */
2267
2268	/* Set up to detect and load shared libraries. */
2269	if (exec_bfd) /* No use without an exec file. */
2270	{
2271	SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid))solib_create_inferior_hook();
2272	remote_check_symbols (symfile_objfile);
2273	}
2274	#endif
2275	}
2276
2277	/* This takes a program previously attached to and detaches it. After
2278	this is done, GDB can be used to debug some other program. We
2279	better not have left any breakpoints in the target program or it'll
2280	die when it hits one. */
2281
2282	static void
2283	remote_detach (char *args, int from_tty)
2284	{
2285	struct remote_state *rs = get_remote_state ();
2286	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2287
2288	if (args)
2289	error ("Argument given to \"detach\" when remotely debugging.");
2290
2291	/* Tell the remote target to detach. */
2292	strcpy (buf, "D");
2293	remote_send (buf, (rs->remote_packet_size));
2294
2295	/* Unregister the file descriptor from the event loop. */
2296	if (target_is_async_p ()(current_target.to_is_async_p()))
2297	serial_async (remote_desc, NULL((void*)0), 0);
2298
2299	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
2300	if (from_tty)
2301	puts_filtered ("Ending remote debugging.\n");
2302	}
2303
2304	/* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2305
2306	static void
2307	remote_disconnect (char *args, int from_tty)
2308	{
2309	struct remote_state *rs = get_remote_state ();
2310	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2311
2312	if (args)
2313	error ("Argument given to \"detach\" when remotely debugging.");
2314
2315	/* Unregister the file descriptor from the event loop. */
2316	if (target_is_async_p ()(current_target.to_is_async_p()))
2317	serial_async (remote_desc, NULL((void*)0), 0);
2318
2319	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
2320	if (from_tty)
2321	puts_filtered ("Ending remote debugging.\n");
2322	}
2323
2324	/* Convert hex digit A to a number. */
2325
2326	static int
2327	fromhex (int a)
2328	{
2329	if (a >= '0' && a <= '9')
2330	return a - '0';
2331	else if (a >= 'a' && a <= 'f')
2332	return a - 'a' + 10;
2333	else if (a >= 'A' && a <= 'F')
2334	return a - 'A' + 10;
2335	else
2336	error ("Reply contains invalid hex digit %d", a);
2337	}
2338
2339	static int
2340	hex2bin (const char hex, char bin, int count)
2341	{
2342	int i;
2343
2344	for (i = 0; i < count; i++)
2345	{
2346	if (hex[0] == 0 \|\| hex[1] == 0)
2347	{
2348	/* Hex string is short, or of uneven length.
2349	Return the count that has been converted so far. */
2350	return i;
2351	}
2352	bin++ = fromhex (hex[0]) 16 + fromhex (hex[1]);
2353	hex += 2;
2354	}
2355	return i;
2356	}
2357
2358	/* Convert number NIB to a hex digit. */
2359
2360	static int
2361	tohex (int nib)
2362	{
2363	if (nib < 10)
2364	return '0' + nib;
2365	else
2366	return 'a' + nib - 10;
2367	}
2368
2369	static int
2370	bin2hex (const char bin, char hex, int count)
2371	{
2372	int i;
2373	/* May use a length, or a nul-terminated string as input. */
2374	if (count == 0)
2375	count = strlen (bin);
2376
2377	for (i = 0; i < count; i++)
2378	{
2379	hex++ = tohex ((bin >> 4) & 0xf);
2380	hex++ = tohex (bin++ & 0xf);
2381	}
2382	*hex = 0;
2383	return i;
2384	}
2385
2386	/* Check for the availability of vCont. This function should also check
2387	the response. */
2388
2389	static void
2390	remote_vcont_probe (struct remote_state rs, char buf)
2391	{
2392	strcpy (buf, "vCont?");
2393	putpkt (buf);
2394	getpkt (buf, rs->remote_packet_size, 0);
2395
2396	/* Make sure that the features we assume are supported. */
2397	if (strncmp (buf, "vCont", 5) == 0)
2398	{
2399	char *p = &buf[5];
2400	int support_s, support_S, support_c, support_C;
2401
2402	support_s = 0;
2403	support_S = 0;
2404	support_c = 0;
2405	support_C = 0;
2406	while (p && *p == ';')
2407	{
2408	p++;
2409	if (p == 's' && ((p + 1) == ';' \|\| *(p + 1) == 0))
2410	support_s = 1;
2411	else if (p == 'S' && ((p + 1) == ';' \|\| *(p + 1) == 0))
2412	support_S = 1;
2413	else if (p == 'c' && ((p + 1) == ';' \|\| *(p + 1) == 0))
2414	support_c = 1;
2415	else if (p == 'C' && ((p + 1) == ';' \|\| *(p + 1) == 0))
2416	support_C = 1;
2417
2418	p = strchr (p, ';');
2419	}
2420
2421	/* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2422	BUF will make packet_ok disable the packet. */
2423	if (!support_s \|\| !support_S \|\| !support_c \|\| !support_C)
2424	buf[0] = 0;
2425	}
2426
2427	packet_ok (buf, &remote_protocol_vcont);
2428	}
2429
2430	/* Resume the remote inferior by using a "vCont" packet. The thread
2431	to be resumed is PTID; STEP and SIGGNAL indicate whether the
2432	resumed thread should be single-stepped and/or signalled. If PTID's
2433	PID is -1, then all threads are resumed; the thread to be stepped and/or
2434	signalled is given in the global INFERIOR_PTID. This function returns
2435	non-zero iff it resumes the inferior.
2436
2437	This function issues a strict subset of all possible vCont commands at the
2438	moment. */
2439
2440	static int
2441	remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
2442	{
2443	struct remote_state *rs = get_remote_state ();
2444	int pid = PIDGET (ptid)(ptid_get_pid (ptid));
2445	char buf = NULL((void)0), *outbuf;
2446	struct cleanup *old_cleanup;
2447
2448	buf = xmalloc (rs->remote_packet_size);
2449	old_cleanup = make_cleanup (xfree, buf);
2450
2451	if (remote_protocol_vcont.support == PACKET_SUPPORT_UNKNOWN)
2452	remote_vcont_probe (rs, buf);
2453
2454	if (remote_protocol_vcont.support == PACKET_DISABLE)
2455	{
2456	do_cleanups (old_cleanup);
2457	return 0;
2458	}
2459
2460	/* If we could generate a wider range of packets, we'd have to worry
2461	about overflowing BUF. Should there be a generic
2462	"multi-part-packet" packet? */
2463
2464	if (PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)) == MAGIC_NULL_PID42000)
2465	{
2466	/* MAGIC_NULL_PTID means that we don't have any active threads, so we
2467	don't have any PID numbers the inferior will understand. Make sure
2468	to only send forms that do not specify a PID. */
2469	if (step && siggnal != TARGET_SIGNAL_0)
2470	outbuf = xstrprintf ("vCont;S%02x", siggnal);
2471	else if (step)
2472	outbuf = xstrprintf ("vCont;s");
2473	else if (siggnal != TARGET_SIGNAL_0)
2474	outbuf = xstrprintf ("vCont;C%02x", siggnal);
2475	else
2476	outbuf = xstrprintf ("vCont;c");
2477	}
2478	else if (pid == -1)
2479	{
2480	/* Resume all threads, with preference for INFERIOR_PTID. */
2481	if (step && siggnal != TARGET_SIGNAL_0)
2482	outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
2483	PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)));
2484	else if (step)
2485	outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)));
2486	else if (siggnal != TARGET_SIGNAL_0)
2487	outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
2488	PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)));
2489	else
2490	outbuf = xstrprintf ("vCont;c");
2491	}
2492	else
2493	{
2494	/* Scheduler locking; resume only PTID. */
2495	if (step && siggnal != TARGET_SIGNAL_0)
2496	outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
2497	else if (step)
2498	outbuf = xstrprintf ("vCont;s:%x", pid);
2499	else if (siggnal != TARGET_SIGNAL_0)
2500	outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
2501	else
2502	outbuf = xstrprintf ("vCont;c:%x", pid);
2503	}
2504
2505	gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size)((void) ((outbuf && strlen (outbuf) < rs->remote_packet_size ) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 2505, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "outbuf && strlen (outbuf) < rs->remote_packet_size" ), 0)));
2506	make_cleanup (xfree, outbuf);
2507
2508	putpkt (outbuf);
2509
2510	do_cleanups (old_cleanup);
2511
2512	return 1;
2513	}
2514
2515	/* Tell the remote machine to resume. */
2516
2517	static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2518
2519	static int last_sent_step;
2520
2521	static void
2522	remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
2523	{
2524	struct remote_state *rs = get_remote_state ();
2525	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2526	int pid = PIDGET (ptid)(ptid_get_pid (ptid));
2527	char *p;
2528
2529	last_sent_signal = siggnal;
2530	last_sent_step = step;
2531
2532	/* A hook for when we need to do something at the last moment before
2533	resumption. */
2534	if (deprecated_target_resume_hook)
2535	(*deprecated_target_resume_hook) ();
2536
2537	/* The vCont packet doesn't need to specify threads via Hc. */
2538	if (remote_vcont_resume (ptid, step, siggnal))
2539	return;
2540
2541	/* All other supported resume packets do use Hc, so call set_thread. */
2542	if (pid == -1)
2543	set_thread (0, 0); /* run any thread */
2544	else
2545	set_thread (pid, 0); /* run this thread */
2546
2547	if (siggnal != TARGET_SIGNAL_0)
2548	{
2549	buf[0] = step ? 'S' : 'C';
2550	buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2551	buf[2] = tohex (((int) siggnal) & 0xf);
2552	buf[3] = '\0';
2553	}
2554	else
2555	strcpy (buf, step ? "s" : "c");
2556
2557	putpkt (buf);
2558	}
2559
2560	/* Same as remote_resume, but with async support. */
2561	static void
2562	remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
2563	{
2564	remote_resume (ptid, step, siggnal);
2565
2566	/* We are about to start executing the inferior, let's register it
2567	with the event loop. NOTE: this is the one place where all the
2568	execution commands end up. We could alternatively do this in each
2569	of the execution commands in infcmd.c.*/
2570	/* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2571	into infcmd.c in order to allow inferior function calls to work
2572	NOT asynchronously. */
2573	if (target_can_async_p ()(current_target.to_can_async_p ()))
2574	target_async (inferior_event_handler, 0)(current_target.to_async((inferior_event_handler), (0)));
2575	/* Tell the world that the target is now executing. */
2576	/* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2577	this? Instead, should the client of target just assume (for
2578	async targets) that the target is going to start executing? Is
2579	this information already found in the continuation block? */
2580	if (target_is_async_p ()(current_target.to_is_async_p()))
2581	target_executing = 1;
2582	}
2583
2584
2585	/* Set up the signal handler for SIGINT, while the target is
2586	executing, ovewriting the 'regular' SIGINT signal handler. */
2587	static void
2588	initialize_sigint_signal_handler (void)
2589	{
2590	sigint_remote_token =
2591	create_async_signal_handler (async_remote_interrupt, NULL((void*)0));
2592	signal (SIGINT2, handle_remote_sigint);
2593	}
2594
2595	/* Signal handler for SIGINT, while the target is executing. */
2596	static void
2597	handle_remote_sigint (int sig)
2598	{
2599	signal (sig, handle_remote_sigint_twice);
2600	sigint_remote_twice_token =
2601	create_async_signal_handler (async_remote_interrupt_twice, NULL((void*)0));
2602	mark_async_signal_handler_wrapper (sigint_remote_token);
2603	}
2604
2605	/* Signal handler for SIGINT, installed after SIGINT has already been
2606	sent once. It will take effect the second time that the user sends
2607	a ^C. */
2608	static void
2609	handle_remote_sigint_twice (int sig)
2610	{
2611	signal (sig, handle_sigint);
2612	sigint_remote_twice_token =
2613	create_async_signal_handler (inferior_event_handler_wrapper, NULL((void*)0));
2614	mark_async_signal_handler_wrapper (sigint_remote_twice_token);
2615	}
2616
2617	/* Perform the real interruption of the target execution, in response
2618	to a ^C. */
2619	static void
2620	async_remote_interrupt (gdb_client_data arg)
2621	{
2622	if (remote_debug)
2623	fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2624
2625	target_stopcurrent_target.to_stop ();
2626	}
2627
2628	/* Perform interrupt, if the first attempt did not succeed. Just give
2629	up on the target alltogether. */
2630	void
2631	async_remote_interrupt_twice (gdb_client_data arg)
2632	{
2633	if (remote_debug)
2634	fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
2635	/* Do something only if the target was not killed by the previous
2636	cntl-C. */
2637	if (target_executing)
2638	{
2639	interrupt_query ();
2640	signal (SIGINT2, handle_remote_sigint);
2641	}
2642	}
2643
2644	/* Reinstall the usual SIGINT handlers, after the target has
2645	stopped. */
2646	static void
2647	cleanup_sigint_signal_handler (void *dummy)
2648	{
2649	signal (SIGINT2, handle_sigint);
2650	if (sigint_remote_twice_token)
2651	delete_async_signal_handler ((struct async_signal_handler **) & sigint_remote_twice_token);
2652	if (sigint_remote_token)
2653	delete_async_signal_handler ((struct async_signal_handler **) & sigint_remote_token);
2654	}
2655
2656	/* Send ^C to target to halt it. Target will respond, and send us a
2657	packet. */
2658	static void (*ofunc) (int);
2659
2660	/* The command line interface's stop routine. This function is installed
2661	as a signal handler for SIGINT. The first time a user requests a
2662	stop, we call remote_stop to send a break or ^C. If there is no
2663	response from the target (it didn't stop when the user requested it),
2664	we ask the user if he'd like to detach from the target. */
2665	static void
2666	remote_interrupt (int signo)
2667	{
2668	/* If this doesn't work, try more severe steps. */
2669	signal (signo, remote_interrupt_twice);
2670
2671	if (remote_debug)
2672	fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2673
2674	target_stopcurrent_target.to_stop ();
2675	}
2676
2677	/* The user typed ^C twice. */
2678
2679	static void
2680	remote_interrupt_twice (int signo)
2681	{
2682	signal (signo, ofunc);
2683	interrupt_query ();
2684	signal (signo, remote_interrupt);
2685	}
2686
2687	/* This is the generic stop called via the target vector. When a target
2688	interrupt is requested, either by the command line or the GUI, we
2689	will eventually end up here. */
2690	static void
2691	remote_stop (void)
2692	{
2693	/* Send a break or a ^C, depending on user preference. */
2694	if (remote_debug)
2695	fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
2696
2697	if (remote_break)
2698	serial_send_break (remote_desc);
2699	else
2700	serial_write (remote_desc, "\003", 1);
2701	}
2702
2703	/* Ask the user what to do when an interrupt is received. */
2704
2705	static void
2706	interrupt_query (void)
2707	{
2708	target_terminal_ours ()(*current_target.to_terminal_ours) ();
2709
2710	if (query ("Interrupted while waiting for the program.\n\
2711	Give up (and stop debugging it)? "))
2712	{
2713	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
2714	throw_exception (RETURN_QUIT);
2715	}
2716
2717	target_terminal_inferior ()(*current_target.to_terminal_inferior) ();
2718	}
2719
2720	/* Enable/disable target terminal ownership. Most targets can use
2721	terminal groups to control terminal ownership. Remote targets are
2722	different in that explicit transfer of ownership to/from GDB/target
2723	is required. */
2724
2725	static void
2726	remote_async_terminal_inferior (void)
2727	{
2728	/* FIXME: cagney/1999-09-27: Shouldn't need to test for
2729	sync_execution here. This function should only be called when
2730	GDB is resuming the inferior in the forground. A background
2731	resume (``run&'') should leave GDB in control of the terminal and
2732	consequently should not call this code. */
2733	if (!sync_execution)
2734	return;
2735	/* FIXME: cagney/1999-09-27: Closely related to the above. Make
2736	calls target_terminal_*() idenpotent. The event-loop GDB talking
2737	to an asynchronous target with a synchronous command calls this
2738	function from both event-top.c and infrun.c/infcmd.c. Once GDB
2739	stops trying to transfer the terminal to the target when it
2740	shouldn't this guard can go away. */
2741	if (!remote_async_terminal_ours_p)
2742	return;
2743	delete_file_handler (input_fd);
2744	remote_async_terminal_ours_p = 0;
2745	initialize_sigint_signal_handler ();
2746	/* NOTE: At this point we could also register our selves as the
2747	recipient of all input. Any characters typed could then be
2748	passed on down to the target. */
2749	}
2750
2751	static void
2752	remote_async_terminal_ours (void)
2753	{
2754	/* See FIXME in remote_async_terminal_inferior. */
2755	if (!sync_execution)
2756	return;
2757	/* See FIXME in remote_async_terminal_inferior. */
2758	if (remote_async_terminal_ours_p)
2759	return;
2760	cleanup_sigint_signal_handler (NULL((void*)0));
2761	add_file_handler (input_fd, stdin_event_handler, 0);
2762	remote_async_terminal_ours_p = 1;
2763	}
2764
2765	/* If nonzero, ignore the next kill. */
2766
2767	int kill_kludge;
2768
2769	void
2770	remote_console_output (char *msg)
2771	{
2772	char *p;
2773
2774	for (p = msg; p[0] && p[1]; p += 2)
2775	{
2776	char tb[2];
2777	char c = fromhex (p[0]) * 16 + fromhex (p[1]);
2778	tb[0] = c;
2779	tb[1] = 0;
2780	fputs_unfiltered (tb, gdb_stdtarg);
2781	}
2782	gdb_flush (gdb_stdtarg);
2783	}
2784
2785	/* Wait until the remote machine stops, then return,
2786	storing status in STATUS just as `wait' would.
2787	Returns "pid", which in the case of a multi-threaded
2788	remote OS, is the thread-id. */
2789
2790	static ptid_t
2791	remote_wait (ptid_t ptid, struct target_waitstatus *status)
2792	{
2793	struct remote_state *rs = get_remote_state ();
2794	unsigned char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2795	ULONGESTunsigned long thread_num = -1;
2796	ULONGESTunsigned long addr;
2797
2798	status->kind = TARGET_WAITKIND_EXITED;
2799	status->value.integer = 0;
2800
2801	while (1)
2802	{
2803	unsigned char *p;
2804
2805	ofunc = signal (SIGINT2, remote_interrupt);
2806	getpkt (buf, (rs->remote_packet_size), 1);
2807	signal (SIGINT2, ofunc);
2808
2809	/* This is a hook for when we need to do something (perhaps the
2810	collection of trace data) every time the target stops. */
2811	if (deprecated_target_wait_loop_hook)
2812	(*deprecated_target_wait_loop_hook) ();
2813
2814	remote_stopped_by_watchpoint_p = 0;
2815
2816	switch (buf[0])
2817	{
2818	case 'E': /* Error of some sort */
2819	warning ("Remote failure reply: %s", buf);
2820	continue;
2821	case 'F': /* File-I/O request */
2822	remote_fileio_request (buf);
2823	continue;
2824	case 'T': /* Status with PC, SP, FP, ... */
2825	{
2826	int i;
2827	char regs[MAX_REGISTER_SIZE];
2828
2829	/* Expedited reply, containing Signal, {regno, reg} repeat */
2830	/* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2831	ss = signal number
2832	n... = register number
2833	r... = register contents
2834	*/
2835	p = &buf[3]; /* after Txx */
2836
2837	while (*p)
2838	{
2839	unsigned char *p1;
2840	char *p_temp;
2841	int fieldsize;
2842	LONGESTlong pnum = 0;
2843
2844	/* If the packet contains a register number save it in pnum
2845	and set p1 to point to the character following it.
2846	Otherwise p1 points to p. */
2847
2848	/* If this packet is an awatch packet, don't parse the 'a'
2849	as a register number. */
2850
2851	if (strncmp (p, "awatch", strlen("awatch")) != 0)
2852	{
2853	/* Read the ``P'' register number. */
2854	pnum = strtol (p, &p_temp, 16);
2855	p1 = (unsigned char *) p_temp;
2856	}
2857	else
2858	p1 = p;
2859
2860	if (p1 == p) /* No register number present here */
2861	{
2862	p1 = (unsigned char *) strchr (p, ':');
2863	if (p1 == NULL((void*)0))
2864	warning ("Malformed packet(a) (missing colon): %s\n\
2865	Packet: '%s'\n",
2866	p, buf);
2867	if (strncmp (p, "thread", p1 - p) == 0)
2868	{
2869	p_temp = unpack_varlen_hex (++p1, &thread_num);
2870	record_currthread (thread_num);
2871	p = (unsigned char *) p_temp;
2872	}
2873	else if ((strncmp (p, "watch", p1 - p) == 0)
2874	\|\| (strncmp (p, "rwatch", p1 - p) == 0)
2875	\|\| (strncmp (p, "awatch", p1 - p) == 0))
2876	{
2877	remote_stopped_by_watchpoint_p = 1;
2878	p = unpack_varlen_hex (++p1, &addr);
2879	remote_watch_data_address = (CORE_ADDR)addr;
2880	}
2881	else
2882	{
2883	/* Silently skip unknown optional info. */
2884	p_temp = strchr (p1 + 1, ';');
2885	if (p_temp)
2886	p = (unsigned char *) p_temp;
2887	}
2888	}
2889	else
2890	{
2891	struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
2892	p = p1;
2893
2894	if (*p++ != ':')
2895	error ("Malformed packet(b) (missing colon): %s\nPacket: '%s'\n",
2896	p, buf);
2897
2898	if (reg == NULL((void*)0))
2899	error ("Remote sent bad register number %s: %s\nPacket: '%s'\n",
2900	phex_nz (pnum, 0), p, buf);
2901
2902	fieldsize = hex2bin (p, regs, register_size (current_gdbarch, reg->regnum));
2903	p += 2 * fieldsize;
2904	if (fieldsize < register_size (current_gdbarch, reg->regnum))
2905	warning ("Remote reply is too short: %s", buf);
2906	regcache_raw_supply (current_regcache, reg->regnum, regs);
2907	}
2908
2909	if (*p++ != ';')
2910	error ("Remote register badly formatted: %s\nhere: %s", buf, p);
2911	}
2912	}
2913	/* fall through */
2914	case 'S': /* Old style status, just signal only */
2915	status->kind = TARGET_WAITKIND_STOPPED;
2916	status->value.sig = (enum target_signal)
2917	(((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2918
2919	if (buf[3] == 'p')
2920	{
2921	thread_num = strtol ((const char ) &buf[4], NULL((void)0), 16);
2922	record_currthread (thread_num);
2923	}
2924	goto got_status;
2925	case 'W': /* Target exited */
2926	{
2927	/* The remote process exited. */
2928	status->kind = TARGET_WAITKIND_EXITED;
2929	status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
2930	goto got_status;
2931	}
2932	case 'X':
2933	status->kind = TARGET_WAITKIND_SIGNALLED;
2934	status->value.sig = (enum target_signal)
2935	(((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2936	kill_kludge = 1;
2937
2938	goto got_status;
2939	case 'O': /* Console output */
2940	remote_console_output (buf + 1);
2941	continue;
2942	case '\0':
2943	if (last_sent_signal != TARGET_SIGNAL_0)
2944	{
2945	/* Zero length reply means that we tried 'S' or 'C' and
2946	the remote system doesn't support it. */
2947	target_terminal_ours_for_output ()(*current_target.to_terminal_ours_for_output) ();
2948	printf_filtered
2949	("Can't send signals to this remote system. %s not sent.\n",
2950	target_signal_to_name (last_sent_signal));
2951	last_sent_signal = TARGET_SIGNAL_0;
2952	target_terminal_inferior ()(*current_target.to_terminal_inferior) ();
2953
2954	strcpy ((char *) buf, last_sent_step ? "s" : "c");
2955	putpkt ((char *) buf);
2956	continue;
2957	}
2958	/* else fallthrough */
2959	default:
2960	warning ("Invalid remote reply: %s", buf);
2961	continue;
2962	}
2963	}
2964	got_status:
2965	if (thread_num != -1)
2966	{
2967	return pid_to_ptid (thread_num);
2968	}
2969	return inferior_ptid;
2970	}
2971
2972	/* Async version of remote_wait. */
2973	static ptid_t
2974	remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
2975	{
2976	struct remote_state *rs = get_remote_state ();
2977	unsigned char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
2978	ULONGESTunsigned long thread_num = -1;
2979	ULONGESTunsigned long addr;
2980
2981	status->kind = TARGET_WAITKIND_EXITED;
2982	status->value.integer = 0;
2983
2984	remote_stopped_by_watchpoint_p = 0;
2985
2986	while (1)
2987	{
2988	unsigned char *p;
2989
2990	if (!target_is_async_p ()(current_target.to_is_async_p()))
2991	ofunc = signal (SIGINT2, remote_interrupt);
2992	/* FIXME: cagney/1999-09-27: If we're in async mode we should
2993	_never_ wait for ever -> test on target_is_async_p().
2994	However, before we do that we need to ensure that the caller
2995	knows how to take the target into/out of async mode. */
2996	getpkt (buf, (rs->remote_packet_size), wait_forever_enabled_p);
2997	if (!target_is_async_p ()(current_target.to_is_async_p()))
2998	signal (SIGINT2, ofunc);
2999
3000	/* This is a hook for when we need to do something (perhaps the
3001	collection of trace data) every time the target stops. */
3002	if (deprecated_target_wait_loop_hook)
3003	(*deprecated_target_wait_loop_hook) ();
3004
3005	switch (buf[0])
3006	{
3007	case 'E': /* Error of some sort */
3008	warning ("Remote failure reply: %s", buf);
3009	continue;
3010	case 'F': /* File-I/O request */
3011	remote_fileio_request (buf);
3012	continue;
3013	case 'T': /* Status with PC, SP, FP, ... */
3014	{
3015	int i;
3016	char regs[MAX_REGISTER_SIZE];
3017
3018	/* Expedited reply, containing Signal, {regno, reg} repeat */
3019	/* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3020	ss = signal number
3021	n... = register number
3022	r... = register contents
3023	*/
3024	p = &buf[3]; /* after Txx */
3025
3026	while (*p)
3027	{
3028	unsigned char *p1;
3029	char *p_temp;
3030	int fieldsize;
3031	long pnum = 0;
3032
3033	/* If the packet contains a register number, save it in pnum
3034	and set p1 to point to the character following it.
3035	Otherwise p1 points to p. */
3036
3037	/* If this packet is an awatch packet, don't parse the 'a'
3038	as a register number. */
3039
3040	if (!strncmp (p, "awatch", strlen ("awatch")) != 0)
3041	{
3042	/* Read the register number. */
3043	pnum = strtol (p, &p_temp, 16);
3044	p1 = (unsigned char *) p_temp;
3045	}
3046	else
3047	p1 = p;
3048
3049	if (p1 == p) /* No register number present here */
3050	{
3051	p1 = (unsigned char *) strchr (p, ':');
3052	if (p1 == NULL((void*)0))
3053	error ("Malformed packet(a) (missing colon): %s\nPacket: '%s'\n",
3054	p, buf);
3055	if (strncmp (p, "thread", p1 - p) == 0)
3056	{
3057	p_temp = unpack_varlen_hex (++p1, &thread_num);
3058	record_currthread (thread_num);
3059	p = (unsigned char *) p_temp;
3060	}
3061	else if ((strncmp (p, "watch", p1 - p) == 0)
3062	\|\| (strncmp (p, "rwatch", p1 - p) == 0)
3063	\|\| (strncmp (p, "awatch", p1 - p) == 0))
3064	{
3065	remote_stopped_by_watchpoint_p = 1;
3066	p = unpack_varlen_hex (++p1, &addr);
3067	remote_watch_data_address = (CORE_ADDR)addr;
3068	}
3069	else
3070	{
3071	/* Silently skip unknown optional info. */
3072	p_temp = (unsigned char *) strchr (p1 + 1, ';');
3073	if (p_temp)
3074	p = p_temp;
3075	}
3076	}
3077
3078	else
3079	{
3080	struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
3081	p = p1;
3082	if (*p++ != ':')
3083	error ("Malformed packet(b) (missing colon): %s\nPacket: '%s'\n",
3084	p, buf);
3085
3086	if (reg == NULL((void*)0))
3087	error ("Remote sent bad register number %ld: %s\nPacket: '%s'\n",
3088	pnum, p, buf);
3089
3090	fieldsize = hex2bin (p, regs, register_size (current_gdbarch, reg->regnum));
3091	p += 2 * fieldsize;
3092	if (fieldsize < register_size (current_gdbarch, reg->regnum))
3093	warning ("Remote reply is too short: %s", buf);
3094	regcache_raw_supply (current_regcache, reg->regnum, regs);
3095	}
3096
3097	if (*p++ != ';')
3098	error ("Remote register badly formatted: %s\nhere: %s",
3099	buf, p);
3100	}
3101	}
3102	/* fall through */
3103	case 'S': /* Old style status, just signal only */
3104	status->kind = TARGET_WAITKIND_STOPPED;
3105	status->value.sig = (enum target_signal)
3106	(((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3107
3108	if (buf[3] == 'p')
3109	{
3110	thread_num = strtol ((const char ) &buf[4], NULL((void)0), 16);
3111	record_currthread (thread_num);
3112	}
3113	goto got_status;
3114	case 'W': /* Target exited */
3115	{
3116	/* The remote process exited. */
3117	status->kind = TARGET_WAITKIND_EXITED;
3118	status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3119	goto got_status;
3120	}
3121	case 'X':
3122	status->kind = TARGET_WAITKIND_SIGNALLED;
3123	status->value.sig = (enum target_signal)
3124	(((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3125	kill_kludge = 1;
3126
3127	goto got_status;
3128	case 'O': /* Console output */
3129	remote_console_output (buf + 1);
3130	/* Return immediately to the event loop. The event loop will
3131	still be waiting on the inferior afterwards. */
3132	status->kind = TARGET_WAITKIND_IGNORE;
3133	goto got_status;
3134	case '\0':
3135	if (last_sent_signal != TARGET_SIGNAL_0)
3136	{
3137	/* Zero length reply means that we tried 'S' or 'C' and
3138	the remote system doesn't support it. */
3139	target_terminal_ours_for_output ()(*current_target.to_terminal_ours_for_output) ();
3140	printf_filtered
3141	("Can't send signals to this remote system. %s not sent.\n",
3142	target_signal_to_name (last_sent_signal));
3143	last_sent_signal = TARGET_SIGNAL_0;
3144	target_terminal_inferior ()(*current_target.to_terminal_inferior) ();
3145
3146	strcpy ((char *) buf, last_sent_step ? "s" : "c");
3147	putpkt ((char *) buf);
3148	continue;
3149	}
3150	/* else fallthrough */
3151	default:
3152	warning ("Invalid remote reply: %s", buf);
3153	continue;
3154	}
3155	}
3156	got_status:
3157	if (thread_num != -1)
3158	{
3159	return pid_to_ptid (thread_num);
3160	}
3161	return inferior_ptid;
3162	}
3163
3164	/* Number of bytes of registers this stub implements. */
3165
3166	static int register_bytes_found;
3167
3168	/* Read the remote registers into the block REGS. */
3169	/* Currently we just read all the registers, so we don't use regnum. */
3170
3171	static int
3172	fetch_register_using_p (int regnum)
3173	{
3174	struct remote_state *rs = get_remote_state ();
3175	char buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size), p;
3176	char regp[MAX_REGISTER_SIZE];
3177	int i;
3178
3179	p = buf;
3180	*p++ = 'p';
3181	p += hexnumstr (p, regnum);
3182	*p++ = '\0';
3183	remote_send (buf, rs->remote_packet_size);
3184	if (buf[0] != 0 && buf[0] != 'E') {
3185	p = buf;
3186	i = 0;
3187	while (p[0] != 0) {
3188	if (p[1] == 0) {
3189	error("fetch_register_using_p: early buf termination");
3190	return 0;
3191	}
3192	regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
3193	p += 2;
3194	}
3195	regcache_raw_supply (current_regcache, regnum, regp);
3196	return 1;
3197	}
3198
3199	return 0;
3200	}
3201
3202	static void
3203	remote_fetch_registers (int regnum)
3204	{
3205	struct remote_state *rs = get_remote_state ();
3206	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
3207	int i;
3208	char *p;
3209	char *regs = alloca (rs->sizeof_g_packet)__builtin_alloca(rs->sizeof_g_packet);
3210
3211	set_thread (PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)), 1);
3212
3213	if (regnum >= 0)
3214	{
3215	struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
3216	gdb_assert (reg != NULL)((void) ((reg != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 3216, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "reg != NULL" ), 0)));
3217	if (!reg->in_g_packet)
3218	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__3218,
3219	"Attempt to fetch a non G-packet register when this "
3220	"remote.c does not support the p-packet.");
3221	}
3222	switch (remote_protocol_p.support)
3223	{
3224	case PACKET_DISABLE:
3225	break;
3226	case PACKET_ENABLE:
3227	if (fetch_register_using_p (regnum))
3228	return;
3229	else
3230	error ("Protocol error: p packet not recognized by stub");
3231	case PACKET_SUPPORT_UNKNOWN:
3232	if (fetch_register_using_p (regnum))
3233	{
3234	/* The stub recognized the 'p' packet. Remember this. */
3235	remote_protocol_p.support = PACKET_ENABLE;
3236	return;
3237	}
3238	else
3239	{
3240	/* The stub does not support the 'P' packet. Use 'G'
3241	instead, and don't try using 'P' in the future (it
3242	will just waste our time). */
3243	remote_protocol_p.support = PACKET_DISABLE;
3244	break;
3245	}
3246	}
3247
3248	sprintf (buf, "g");
3249	remote_send (buf, (rs->remote_packet_size));
3250
3251	/* Save the size of the packet sent to us by the target. Its used
3252	as a heuristic when determining the max size of packets that the
3253	target can safely receive. */
3254	if ((rs->actual_register_packet_size) == 0)
3255	(rs->actual_register_packet_size) = strlen (buf);
3256
3257	/* Unimplemented registers read as all bits zero. */
3258	memset (regs, 0, rs->sizeof_g_packet);
3259
3260	/* We can get out of synch in various cases. If the first character
3261	in the buffer is not a hex character, assume that has happened
3262	and try to fetch another packet to read. */
3263	while ((buf[0] < '0' \|\| buf[0] > '9')
3264	&& (buf[0] < 'a' \|\| buf[0] > 'f')
3265	&& buf[0] != 'x') /* New: unavailable register value */
3266	{
3267	if (remote_debug)
3268	fprintf_unfiltered (gdb_stdlog,
3269	"Bad register packet; fetching a new packet\n");
3270	getpkt (buf, (rs->remote_packet_size), 0);
3271	}
3272
3273	/* Reply describes registers byte by byte, each byte encoded as two
3274	hex characters. Suck them all up, then supply them to the
3275	register cacheing/storage mechanism. */
3276
3277	p = buf;
3278	for (i = 0; i < rs->sizeof_g_packet; i++)
3279	{
3280	if (p[0] == 0)
3281	break;
3282	if (p[1] == 0)
3283	{
3284	warning ("Remote reply is of odd length: %s", buf);
3285	/* Don't change register_bytes_found in this case, and don't
3286	print a second warning. */
3287	goto supply_them;
3288	}
3289	if (p[0] == 'x' && p[1] == 'x')
3290	regs[i] = 0; /* 'x' */
3291	else
3292	regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3293	p += 2;
3294	}
3295
3296	if (i != register_bytes_found)
3297	{
3298	register_bytes_found = i;
3299	if (REGISTER_BYTES_OK_P ()(gdbarch_register_bytes_ok_p (current_gdbarch))
3300	&& !REGISTER_BYTES_OK (i)(gdbarch_register_bytes_ok (current_gdbarch, i)))
3301	warning ("Remote reply is too short: %s", buf);
3302	}
3303
3304	supply_them:
3305	{
3306	int i;
3307	for (i = 0; i < NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch)); i++)
3308	{
3309	struct packet_reg *r = &rs->regs[i];
3310	if (r->in_g_packet)
3311	{
3312	if (r->offset * 2 >= strlen (buf))
3313	/* A short packet that didn't include the register's
3314	value, this implies that the register is zero (and
3315	not that the register is unavailable). Supply that
3316	zero value. */
3317	regcache_raw_supply (current_regcache, r->regnum, NULL((void*)0));
3318	else if (buf[r->offset * 2] == 'x')
3319	{
3320	gdb_assert (r->offset * 2 < strlen (buf))((void) ((r->offset * 2 < strlen (buf)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c", 3320, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "r->offset * 2 < strlen (buf)"), 0)));
3321	/* The register isn't available, mark it as such (at
3322	the same time setting the value to zero). */
3323	regcache_raw_supply (current_regcache, r->regnum, NULL((void*)0));
3324	set_register_cached (i, -1);
3325	}
3326	else
3327	regcache_raw_supply (current_regcache, r->regnum,
3328	regs + r->offset);
3329	}
3330	}
3331	}
3332	}
3333
3334	/* Prepare to store registers. Since we may send them all (using a
3335	'G' request), we have to read out the ones we don't want to change
3336	first. */
3337
3338	static void
3339	remote_prepare_to_store (void)
3340	{
3341	struct remote_state *rs = get_remote_state ();
3342	int i;
3343	char buf[MAX_REGISTER_SIZE];
3344
3345	/* Make sure the entire registers array is valid. */
3346	switch (remote_protocol_P.support)
3347	{
3348	case PACKET_DISABLE:
3349	case PACKET_SUPPORT_UNKNOWN:
3350	/* Make sure all the necessary registers are cached. */
3351	for (i = 0; i < NUM_REGS(gdbarch_num_regs (current_gdbarch)); i++)
3352	if (rs->regs[i].in_g_packet)
3353	regcache_raw_read (current_regcache, rs->regs[i].regnum, buf);
3354	break;
3355	case PACKET_ENABLE:
3356	break;
3357	}
3358	}
3359
3360	/* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3361	packet was not recognized. */
3362
3363	static int
3364	store_register_using_P (int regnum)
3365	{
3366	struct remote_state *rs = get_remote_state ();
3367	struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
3368	/* Try storing a single register. */
3369	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
3370	char regp[MAX_REGISTER_SIZE];
3371	char *p;
3372	int i;
3373
3374	sprintf (buf, "P%s=", phex_nz (reg->pnum, 0));
3375	p = buf + strlen (buf);
3376	regcache_raw_collect (current_regcache, reg->regnum, regp);
3377	bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
3378	remote_send (buf, rs->remote_packet_size);
3379
3380	return buf[0] != '\0';
3381	}
3382
3383
3384	/* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3385	of the register cache buffer. FIXME: ignores errors. */
3386
3387	static void
3388	remote_store_registers (int regnum)
3389	{
3390	struct remote_state *rs = get_remote_state ();
3391	char *buf;
3392	char *regs;
3393	int i;
3394	char *p;
3395
3396	set_thread (PIDGET (inferior_ptid)(ptid_get_pid (inferior_ptid)), 1);
3397
3398	if (regnum >= 0)
3399	{
3400	switch (remote_protocol_P.support)
3401	{
3402	case PACKET_DISABLE:
3403	break;
3404	case PACKET_ENABLE:
3405	if (store_register_using_P (regnum))
3406	return;
3407	else
3408	error ("Protocol error: P packet not recognized by stub");
3409	case PACKET_SUPPORT_UNKNOWN:
3410	if (store_register_using_P (regnum))
3411	{
3412	/* The stub recognized the 'P' packet. Remember this. */
3413	remote_protocol_P.support = PACKET_ENABLE;
3414	return;
3415	}
3416	else
3417	{
3418	/* The stub does not support the 'P' packet. Use 'G'
3419	instead, and don't try using 'P' in the future (it
3420	will just waste our time). */
3421	remote_protocol_P.support = PACKET_DISABLE;
3422	break;
3423	}
3424	}
3425	}
3426
3427	/* Extract all the registers in the regcache copying them into a
3428	local buffer. */
3429	{
3430	int i;
3431	regs = alloca (rs->sizeof_g_packet)__builtin_alloca(rs->sizeof_g_packet);
3432	memset (regs, 0, rs->sizeof_g_packet);
3433	for (i = 0; i < NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch)); i++)
3434	{
3435	struct packet_reg *r = &rs->regs[i];
3436	if (r->in_g_packet)
3437	regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
3438	}
3439	}
3440
3441	/* Command describes registers byte by byte,
3442	each byte encoded as two hex characters. */
3443	buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
3444	p = buf;
3445	*p++ = 'G';
3446	/* remote_prepare_to_store insures that register_bytes_found gets set. */
3447	bin2hex (regs, p, register_bytes_found);
3448	remote_send (buf, (rs->remote_packet_size));
3449	}
3450
3451
3452	/* Return the number of hex digits in num. */
3453
3454	static int
3455	hexnumlen (ULONGESTunsigned long num)
3456	{
3457	int i;
3458
3459	for (i = 0; num != 0; i++)
3460	num >>= 4;
3461
3462	return max (i, 1)((i) > (1) ? (i) : (1));
3463	}
3464
3465	/* Set BUF to the minimum number of hex digits representing NUM. */
3466
3467	static int
3468	hexnumstr (char *buf, ULONGESTunsigned long num)
3469	{
3470	int len = hexnumlen (num);
3471	return hexnumnstr (buf, num, len);
3472	}
3473
3474
3475	/* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3476
3477	static int
3478	hexnumnstr (char *buf, ULONGESTunsigned long num, int width)
3479	{
3480	int i;
3481
3482	buf[width] = '\0';
3483
3484	for (i = width - 1; i >= 0; i--)
3485	{
3486	buf[i] = "0123456789abcdef"[(num & 0xf)];
3487	num >>= 4;
3488	}
3489
3490	return width;
3491	}
3492
3493	/* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3494
3495	static CORE_ADDR
3496	remote_address_masked (CORE_ADDR addr)
3497	{
3498	if (remote_address_size > 0
3499	&& remote_address_size < (sizeof (ULONGESTunsigned long) * 8))
3500	{
3501	/* Only create a mask when that mask can safely be constructed
3502	in a ULONGEST variable. */
3503	ULONGESTunsigned long mask = 1;
3504	mask = (mask << remote_address_size) - 1;
3505	addr &= mask;
3506	}
3507	return addr;
3508	}
3509
3510	/* Determine whether the remote target supports binary downloading.
3511	This is accomplished by sending a no-op memory write of zero length
3512	to the target at the specified address. It does not suffice to send
3513	the whole packet, since many stubs strip the eighth bit and subsequently
3514	compute a wrong checksum, which causes real havoc with remote_write_bytes.
3515
3516	NOTE: This can still lose if the serial line is not eight-bit
3517	clean. In cases like this, the user should clear "remote
3518	X-packet". */
3519
3520	static void
3521	check_binary_download (CORE_ADDR addr)
3522	{
3523	struct remote_state *rs = get_remote_state ();
3524	switch (remote_protocol_binary_download.support)
3525	{
3526	case PACKET_DISABLE:
3527	break;
3528	case PACKET_ENABLE:
3529	break;
3530	case PACKET_SUPPORT_UNKNOWN:
3531	{
3532	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
3533	char *p;
3534
3535	p = buf;
3536	*p++ = 'X';
3537	p += hexnumstr (p, (ULONGESTunsigned long) addr);
3538	*p++ = ',';
3539	p += hexnumstr (p, (ULONGESTunsigned long) 0);
3540	*p++ = ':';
3541	*p = '\0';
3542
3543	putpkt_binary (buf, (int) (p - buf));
3544	getpkt (buf, (rs->remote_packet_size), 0);
3545
3546	if (buf[0] == '\0')
3547	{
3548	if (remote_debug)
3549	fprintf_unfiltered (gdb_stdlog,
3550	"binary downloading NOT suppported by target\n");
3551	remote_protocol_binary_download.support = PACKET_DISABLE;
3552	}
3553	else
3554	{
3555	if (remote_debug)
3556	fprintf_unfiltered (gdb_stdlog,
3557	"binary downloading suppported by target\n");
3558	remote_protocol_binary_download.support = PACKET_ENABLE;
3559	}
3560	break;
3561	}
3562	}
3563	}
3564
3565	/* Write memory data directly to the remote machine.
3566	This does not inform the data cache; the data cache uses this.
3567	MEMADDR is the address in the remote memory space.
3568	MYADDR is the address of the buffer in our space.
3569	LEN is the number of bytes.
3570
3571	Returns number of bytes transferred, or 0 (setting errno) for
3572	error. Only transfer a single packet. */
3573
3574	int
3575	remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3576	{
3577	unsigned char *buf;
3578	unsigned char *p;
3579	unsigned char *plen;
3580	long sizeof_buf;
3581	int plenlen;
3582	int todo;
3583	int nr_bytes;
3584	int payload_size;
3585	unsigned char *payload_start;
3586
3587	/* Verify that the target can support a binary download. */
3588	check_binary_download (memaddr);
3589
3590	/* Compute the size, and then allocate space for the largest
3591	possible packet. Include space for an extra trailing NUL. */
3592	sizeof_buf = get_memory_write_packet_size () + 1;
3593	buf = alloca (sizeof_buf)__builtin_alloca(sizeof_buf);
3594
3595	/* Compute the size of the actual payload by subtracting out the
3596	packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
3597	payload_size = (get_memory_write_packet_size () - (strlen ("$M,:#NN")
3598	+ hexnumlen (memaddr)
3599	+ hexnumlen (len)));
3600
3601	/* Construct the packet header: "[MX]<memaddr>,<len>:". */
3602
3603	/* Append "[XM]". Compute a best guess of the number of bytes
3604	actually transfered. */
3605	p = buf;
3606	switch (remote_protocol_binary_download.support)
3607	{
3608	case PACKET_ENABLE:
3609	*p++ = 'X';
3610	/* Best guess at number of bytes that will fit. */
3611	todo = min (len, payload_size)((len) < (payload_size) ? (len) : (payload_size));
3612	break;
3613	case PACKET_DISABLE:
3614	*p++ = 'M';
3615	/* num bytes that will fit */
3616	todo = min (len, payload_size / 2)((len) < (payload_size / 2) ? (len) : (payload_size / 2));
3617	break;
3618	case PACKET_SUPPORT_UNKNOWN:
3619	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__3619,
3620	"remote_write_bytes: bad internal state");
3621	default:
3622	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__3622, "bad switch");
3623	}
3624
3625	/* Append "<memaddr>". */
3626	memaddr = remote_address_masked (memaddr);
3627	p += hexnumstr (p, (ULONGESTunsigned long) memaddr);
3628
3629	/* Append ",". */
3630	*p++ = ',';
3631
3632	/* Append <len>. Retain the location/size of <len>. It may need to
3633	be adjusted once the packet body has been created. */
3634	plen = p;
3635	plenlen = hexnumstr (p, (ULONGESTunsigned long) todo);
3636	p += plenlen;
3637
3638	/* Append ":". */
3639	*p++ = ':';
3640	*p = '\0';
3641
3642	/* Append the packet body. */
3643	payload_start = p;
3644	switch (remote_protocol_binary_download.support)
3645	{
3646	case PACKET_ENABLE:
3647	/* Binary mode. Send target system values byte by byte, in
3648	increasing byte addresses. Only escape certain critical
3649	characters. */
3650	for (nr_bytes = 0;
3651	(nr_bytes < todo) && (p - payload_start) < payload_size;
3652	nr_bytes++)
3653	{
3654	switch (myaddr[nr_bytes] & 0xff)
3655	{
3656	case '$':
3657	case '#':
3658	case 0x7d:
3659	/* These must be escaped */
3660	*p++ = 0x7d;
3661	*p++ = (myaddr[nr_bytes] & 0xff) ^ 0x20;
3662	break;
3663	default:
3664	*p++ = myaddr[nr_bytes] & 0xff;
3665	break;
3666	}
3667	}
3668	if (nr_bytes < todo)
3669	{
3670	/* Escape chars have filled up the buffer prematurely,
3671	and we have actually sent fewer bytes than planned.
3672	Fix-up the length field of the packet. Use the same
3673	number of characters as before. */
3674	plen += hexnumnstr (plen, (ULONGESTunsigned long) nr_bytes, plenlen);
3675	plen = ':'; / overwrite \0 from hexnumnstr() */
3676	}
3677	break;
3678	case PACKET_DISABLE:
3679	/* Normal mode: Send target system values byte by byte, in
3680	increasing byte addresses. Each byte is encoded as a two hex
3681	value. */
3682	nr_bytes = bin2hex (myaddr, p, todo);
3683	p += 2 * nr_bytes;
3684	break;
3685	case PACKET_SUPPORT_UNKNOWN:
3686	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__3686,
3687	"remote_write_bytes: bad internal state");
3688	default:
3689	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__3689, "bad switch");
3690	}
3691
3692	putpkt_binary (buf, (int) (p - buf));
3693	getpkt (buf, sizeof_buf, 0);
3694
3695	if (buf[0] == 'E')
3696	{
3697	/* There is no correspondance between what the remote protocol
3698	uses for errors and errno codes. We would like a cleaner way
3699	of representing errors (big enough to include errno codes,
3700	bfd_error codes, and others). But for now just return EIO. */
3701	errno(*__errno()) = EIO5;
3702	return 0;
3703	}
3704
3705	/* Return NR_BYTES, not TODO, in case escape chars caused us to send fewer
3706	bytes than we'd planned. */
3707	return nr_bytes;
3708	}
3709
3710	/* Read memory data directly from the remote machine.
3711	This does not use the data cache; the data cache uses this.
3712	MEMADDR is the address in the remote memory space.
3713	MYADDR is the address of the buffer in our space.
3714	LEN is the number of bytes.
3715
3716	Returns number of bytes transferred, or 0 for error. */
3717
3718	/* NOTE: cagney/1999-10-18: This function (and its siblings in other
3719	remote targets) shouldn't attempt to read the entire buffer.
3720	Instead it should read a single packet worth of data and then
3721	return the byte size of that packet to the caller. The caller (its
3722	caller and its callers caller ;-) already contains code for
3723	handling partial reads. */
3724
3725	int
3726	remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3727	{
3728	char *buf;
3729	int max_buf_size; /* Max size of packet output buffer */
3730	long sizeof_buf;
3731	int origlen;
3732
3733	/* Create a buffer big enough for this packet. */
3734	max_buf_size = get_memory_read_packet_size ();
3735	sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3736	buf = alloca (sizeof_buf)__builtin_alloca(sizeof_buf);
3737
3738	origlen = len;
3739	while (len > 0)
3740	{
3741	char *p;
3742	int todo;
3743	int i;
3744
3745	todo = min (len, max_buf_size / 2)((len) < (max_buf_size / 2) ? (len) : (max_buf_size / 2)); /* num bytes that will fit */
3746
3747	/* construct "m"<memaddr>","<len>" */
3748	/* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3749	memaddr = remote_address_masked (memaddr);
3750	p = buf;
3751	*p++ = 'm';
3752	p += hexnumstr (p, (ULONGESTunsigned long) memaddr);
3753	*p++ = ',';
3754	p += hexnumstr (p, (ULONGESTunsigned long) todo);
3755	*p = '\0';
3756
3757	putpkt (buf);
3758	getpkt (buf, sizeof_buf, 0);
3759
3760	if (buf[0] == 'E'
3761	&& isxdigit (buf[1]) && isxdigit (buf[2])
3762	&& buf[3] == '\0')
3763	{
3764	/* There is no correspondance between what the remote protocol uses
3765	for errors and errno codes. We would like a cleaner way of
3766	representing errors (big enough to include errno codes, bfd_error
3767	codes, and others). But for now just return EIO. */
3768	errno(*__errno()) = EIO5;
3769	return 0;
3770	}
3771
3772	/* Reply describes memory byte by byte,
3773	each byte encoded as two hex characters. */
3774
3775	p = buf;
3776	if ((i = hex2bin (p, myaddr, todo)) < todo)
3777	{
3778	/* Reply is short. This means that we were able to read
3779	only part of what we wanted to. */
3780	return i + (origlen - len);
3781	}
3782	myaddr += todo;
3783	memaddr += todo;
3784	len -= todo;
3785	}
3786	return origlen;
3787	}
3788
3789	/* Read or write LEN bytes from inferior memory at MEMADDR,
3790	transferring to or from debugger address BUFFER. Write to inferior if
3791	SHOULD_WRITE is nonzero. Returns length of data written or read; 0
3792	for error. TARGET is unused. */
3793
3794	static int
3795	remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
3796	int should_write, struct mem_attrib *attrib,
3797	struct target_ops *target)
3798	{
3799	CORE_ADDR targ_addr;
3800	int targ_len;
3801	int res;
3802
3803	/* Should this be the selected frame? */
3804	gdbarch_remote_translate_xfer_address (current_gdbarch, current_regcache,
3805	mem_addr, mem_len,
3806	&targ_addr, &targ_len);
3807	if (targ_len <= 0)
3808	return 0;
3809
3810	if (should_write)
3811	res = remote_write_bytes (targ_addr, buffer, targ_len);
3812	else
3813	res = remote_read_bytes (targ_addr, buffer, targ_len);
3814
3815	return res;
3816	}
3817
3818	static void
3819	remote_files_info (struct target_ops *ignore)
3820	{
3821	puts_filtered ("Debugging a target over a serial line.\n");
3822	}
3823
3824	/* Stuff for dealing with the packets which are part of this protocol.
3825	See comment at top of file for details. */
3826
3827	/* Read a single character from the remote end, masking it down to 7 bits. */
3828
3829	static int
3830	readchar (int timeout)
3831	{
3832	int ch;
3833
3834	ch = serial_readchar (remote_desc, timeout);
3835
3836	if (ch >= 0)
3837	return (ch & 0x7f);
3838
3839	switch ((enum serial_rc) ch)
3840	{
3841	case SERIAL_EOF:
3842	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
3843	error ("Remote connection closed");
3844	/* no return */
3845	case SERIAL_ERROR:
3846	perror_with_name ("Remote communication error");
3847	/* no return */
3848	case SERIAL_TIMEOUT:
3849	break;
3850	}
3851	return ch;
3852	}
3853
3854	/* Send the command in BUF to the remote machine, and read the reply
3855	into BUF. Report an error if we get an error reply. */
3856
3857	static void
3858	remote_send (char *buf,
3859	long sizeof_buf)
3860	{
3861	putpkt (buf);
3862	getpkt (buf, sizeof_buf, 0);
3863
3864	if (buf[0] == 'E')
3865	error ("Remote failure reply: %s", buf);
3866	}
3867
3868	/* Display a null-terminated packet on stdout, for debugging, using C
3869	string notation. */
3870
3871	static void
3872	print_packet (char *buf)
3873	{
3874	puts_filtered ("\"");
3875	fputstr_filtered (buf, '"', gdb_stdout);
3876	puts_filtered ("\"");
3877	}
3878
3879	int
3880	putpkt (char *buf)
3881	{
3882	return putpkt_binary (buf, strlen (buf));
3883	}
3884
3885	/* Send a packet to the remote machine, with error checking. The data
3886	of the packet is in BUF. The string in BUF can be at most (rs->remote_packet_size) - 5
3887	to account for the $, # and checksum, and for a possible /0 if we are
3888	debugging (remote_debug) and want to print the sent packet as a string */
3889
3890	static int
3891	putpkt_binary (char *buf, int cnt)
3892	{
3893	struct remote_state *rs = get_remote_state ();
3894	int i;
3895	unsigned char csum = 0;
3896	char *buf2 = alloca (cnt + 6)__builtin_alloca(cnt + 6);
3897	long sizeof_junkbuf = (rs->remote_packet_size);
3898	char *junkbuf = alloca (sizeof_junkbuf)__builtin_alloca(sizeof_junkbuf);
3899
3900	int ch;
3901	int tcount = 0;
3902	char *p;
3903
3904	/* Copy the packet into buffer BUF2, encapsulating it
3905	and giving it a checksum. */
3906
3907	p = buf2;
3908	*p++ = '$';
3909
3910	for (i = 0; i < cnt; i++)
3911	{
3912	csum += buf[i];
3913	*p++ = buf[i];
3914	}
3915	*p++ = '#';
3916	*p++ = tohex ((csum >> 4) & 0xf);
3917	*p++ = tohex (csum & 0xf);
3918
3919	/* Send it over and over until we get a positive ack. */
3920
3921	while (1)
3922	{
3923	int started_error_output = 0;
3924
3925	if (remote_debug)
3926	{
3927	*p = '\0';
3928	fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
3929	fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
3930	fprintf_unfiltered (gdb_stdlog, "...");
3931	gdb_flush (gdb_stdlog);
3932	}
3933	if (serial_write (remote_desc, buf2, p - buf2))
3934	perror_with_name ("putpkt: write failed");
3935
3936	/* read until either a timeout occurs (-2) or '+' is read */
3937	while (1)
3938	{
3939	ch = readchar (remote_timeout);
3940
3941	if (remote_debug)
3942	{
3943	switch (ch)
3944	{
3945	case '+':
3946	case '-':
3947	case SERIAL_TIMEOUT:
3948	case '$':
3949	if (started_error_output)
3950	{
3951	putchar_unfiltered ('\n');
3952	started_error_output = 0;
3953	}
3954	}
3955	}
3956
3957	switch (ch)
3958	{
3959	case '+':
3960	if (remote_debug)
3961	fprintf_unfiltered (gdb_stdlog, "Ack\n");
3962	return 1;
3963	case '-':
3964	if (remote_debug)
3965	fprintf_unfiltered (gdb_stdlog, "Nak\n");
3966	case SERIAL_TIMEOUT:
3967	tcount++;
3968	if (tcount > 3)
3969	return 0;
3970	break; /* Retransmit buffer */
3971	case '$':
3972	{
3973	if (remote_debug)
3974	fprintf_unfiltered (gdb_stdlog, "Packet instead of Ack, ignoring it\n");
3975	/* It's probably an old response, and we're out of sync.
3976	Just gobble up the packet and ignore it. */
3977	read_frame (junkbuf, sizeof_junkbuf);
3978	continue; /* Now, go look for + */
3979	}
3980	default:
3981	if (remote_debug)
3982	{
3983	if (!started_error_output)
3984	{
3985	started_error_output = 1;
3986	fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
3987	}
3988	fputc_unfiltered (ch & 0177, gdb_stdlog);
3989	}
3990	continue;
3991	}
3992	break; /* Here to retransmit */
3993	}
3994
3995	#if 0
3996	/* This is wrong. If doing a long backtrace, the user should be
3997	able to get out next time we call QUIT, without anything as
3998	violent as interrupt_query. If we want to provide a way out of
3999	here without getting to the next QUIT, it should be based on
4000	hitting ^C twice as in remote_wait. */
4001	if (quit_flag)
4002	{
4003	quit_flag = 0;
4004	interrupt_query ();
4005	}
4006	#endif
4007	}
4008	}
4009
4010	/* Come here after finding the start of the frame. Collect the rest
4011	into BUF, verifying the checksum, length, and handling run-length
4012	compression. No more than sizeof_buf-1 characters are read so that
4013	the buffer can be NUL terminated.
4014
4015	Returns -1 on error, number of characters in buffer (ignoring the
4016	trailing NULL) on success. (could be extended to return one of the
4017	SERIAL status indications). */
4018
4019	static long
4020	read_frame (char *buf,
4021	long sizeof_buf)
4022	{
4023	unsigned char csum;
4024	long bc;
4025	int c;
4026
4027	csum = 0;
4028	bc = 0;
4029
4030	while (1)
4031	{
4032	/* ASSERT (bc < sizeof_buf - 1) - space for trailing NUL */
4033	c = readchar (remote_timeout);
4034	switch (c)
4035	{
4036	case SERIAL_TIMEOUT:
4037	if (remote_debug)
4038	fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
4039	return -1;
4040	case '$':
4041	if (remote_debug)
4042	fputs_filtered ("Saw new packet start in middle of old one\n",
4043	gdb_stdlog);
4044	return -1; /* Start a new packet, count retries */
4045	case '#':
4046	{
4047	unsigned char pktcsum;
4048	int check_0 = 0;
4049	int check_1 = 0;
4050
4051	buf[bc] = '\0';
4052
4053	check_0 = readchar (remote_timeout);
4054	if (check_0 >= 0)
4055	check_1 = readchar (remote_timeout);
4056
4057	if (check_0 == SERIAL_TIMEOUT \|\| check_1 == SERIAL_TIMEOUT)
4058	{
4059	if (remote_debug)
4060	fputs_filtered ("Timeout in checksum, retrying\n", gdb_stdlog);
4061	return -1;
4062	}
4063	else if (check_0 < 0 \|\| check_1 < 0)
4064	{
4065	if (remote_debug)
4066	fputs_filtered ("Communication error in checksum\n", gdb_stdlog);
4067	return -1;
4068	}
4069
4070	pktcsum = (fromhex (check_0) << 4) \| fromhex (check_1);
4071	if (csum == pktcsum)
4072	return bc;
4073
4074	if (remote_debug)
4075	{
4076	fprintf_filtered (gdb_stdlog,
4077	"Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4078	pktcsum, csum);
4079	fputs_filtered (buf, gdb_stdlog);
4080	fputs_filtered ("\n", gdb_stdlog);
4081	}
4082	/* Number of characters in buffer ignoring trailing
4083	NUL. */
4084	return -1;
4085	}
4086	case '': / Run length encoding */
4087	{
4088	int repeat;
4089	csum += c;
4090
4091	c = readchar (remote_timeout);
4092	csum += c;
4093	repeat = c - ' ' + 3; /* Compute repeat count */
4094
4095	/* The character before ``'' is repeated. /
4096
4097	if (repeat > 0 && repeat <= 255
4098	&& bc > 0
4099	&& bc + repeat - 1 < sizeof_buf - 1)
4100	{
4101	memset (&buf[bc], buf[bc - 1], repeat);
4102	bc += repeat;
4103	continue;
4104	}
4105
4106	buf[bc] = '\0';
4107	printf_filtered ("Repeat count %d too large for buffer: ", repeat);
4108	puts_filtered (buf);
4109	puts_filtered ("\n");
4110	return -1;
4111	}
4112	default:
4113	if (bc < sizeof_buf - 1)
4114	{
4115	buf[bc++] = c;
4116	csum += c;
4117	continue;
4118	}
4119
4120	buf[bc] = '\0';
4121	puts_filtered ("Remote packet too long: ");
4122	puts_filtered (buf);
4123	puts_filtered ("\n");
4124
4125	return -1;
4126	}
4127	}
4128	}
4129
4130	/* Read a packet from the remote machine, with error checking, and
4131	store it in BUF. If FOREVER, wait forever rather than timing out;
4132	this is used (in synchronous mode) to wait for a target that is is
4133	executing user code to stop. */
4134	/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4135	don't have to change all the calls to getpkt to deal with the
4136	return value, because at the moment I don't know what the right
4137	thing to do it for those. */
4138	void
4139	getpkt (char *buf,
4140	long sizeof_buf,
4141	int forever)
4142	{
4143	int timed_out;
4144
4145	timed_out = getpkt_sane (buf, sizeof_buf, forever);
4146	}
4147
4148
4149	/* Read a packet from the remote machine, with error checking, and
4150	store it in BUF. If FOREVER, wait forever rather than timing out;
4151	this is used (in synchronous mode) to wait for a target that is is
4152	executing user code to stop. If FOREVER == 0, this function is
4153	allowed to time out gracefully and return an indication of this to
4154	the caller. */
4155	static int
4156	getpkt_sane (char *buf,
4157	long sizeof_buf,
4158	int forever)
4159	{
4160	int c;
4161	int tries;
4162	int timeout;
4163	int val;
4164
4165	strcpy (buf, "timeout");
4166
4167	if (forever)
4168	{
4169	timeout = watchdog > 0 ? watchdog : -1;
4170	}
4171
4172	else
4173	timeout = remote_timeout;
4174
4175	#define MAX_TRIES3 3
4176
4177	for (tries = 1; tries <= MAX_TRIES3; tries++)
4178	{
4179	/* This can loop forever if the remote side sends us characters
4180	continuously, but if it pauses, we'll get a zero from readchar
4181	because of timeout. Then we'll count that as a retry. */
4182
4183	/* Note that we will only wait forever prior to the start of a packet.
4184	After that, we expect characters to arrive at a brisk pace. They
4185	should show up within remote_timeout intervals. */
4186
4187	do
4188	{
4189	c = readchar (timeout);
4190
4191	if (c == SERIAL_TIMEOUT)
4192	{
4193	if (forever) /* Watchdog went off? Kill the target. */
4194	{
4195	QUIT{ if (quit_flag) quit (); if (deprecated_interactive_hook) deprecated_interactive_hook (); };
4196	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
4197	error ("Watchdog has expired. Target detached.\n");
4198	}
4199	if (remote_debug)
4200	fputs_filtered ("Timed out.\n", gdb_stdlog);
4201	goto retry;
4202	}
4203	}
4204	while (c != '$');
4205
4206	/* We've found the start of a packet, now collect the data. */
4207
4208	val = read_frame (buf, sizeof_buf);
4209
4210	if (val >= 0)
4211	{
4212	if (remote_debug)
4213	{
4214	fprintf_unfiltered (gdb_stdlog, "Packet received: ");
4215	fputstr_unfiltered (buf, 0, gdb_stdlog);
4216	fprintf_unfiltered (gdb_stdlog, "\n");
4217	}
4218	serial_write (remote_desc, "+", 1);
4219	return 0;
4220	}
4221
4222	/* Try the whole thing again. */
4223	retry:
4224	serial_write (remote_desc, "-", 1);
4225	}
4226
4227	/* We have tried hard enough, and just can't receive the packet. Give up. */
4228
4229	printf_unfiltered ("Ignoring packet error, continuing...\n");
4230	serial_write (remote_desc, "+", 1);
4231	return 1;
4232	}
4233
4234	static void
4235	remote_kill (void)
4236	{
4237	/* For some mysterious reason, wait_for_inferior calls kill instead of
4238	mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4239	if (kill_kludge)
4240	{
4241	kill_kludge = 0;
4242	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
4243	return;
4244	}
4245
4246	/* Use catch_errors so the user can quit from gdb even when we aren't on
4247	speaking terms with the remote system. */
4248	catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR(1 << (int)(-RETURN_ERROR)));
4249
4250	/* Don't wait for it to die. I'm not really sure it matters whether
4251	we do or not. For the existing stubs, kill is a noop. */
4252	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
4253	}
4254
4255	/* Async version of remote_kill. */
4256	static void
4257	remote_async_kill (void)
4258	{
4259	/* Unregister the file descriptor from the event loop. */
4260	if (target_is_async_p ()(current_target.to_is_async_p()))
4261	serial_async (remote_desc, NULL((void*)0), 0);
4262
4263	/* For some mysterious reason, wait_for_inferior calls kill instead of
4264	mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4265	if (kill_kludge)
4266	{
4267	kill_kludge = 0;
4268	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
4269	return;
4270	}
4271
4272	/* Use catch_errors so the user can quit from gdb even when we aren't on
4273	speaking terms with the remote system. */
4274	catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR(1 << (int)(-RETURN_ERROR)));
4275
4276	/* Don't wait for it to die. I'm not really sure it matters whether
4277	we do or not. For the existing stubs, kill is a noop. */
4278	target_mourn_inferior ()(*current_target.to_mourn_inferior) ();
4279	}
4280
4281	static void
4282	remote_mourn (void)
4283	{
4284	remote_mourn_1 (&remote_ops);
4285	}
4286
4287	static void
4288	remote_async_mourn (void)
4289	{
4290	remote_mourn_1 (&remote_async_ops);
4291	}
4292
4293	static void
4294	extended_remote_mourn (void)
4295	{
4296	/* We do _not_ want to mourn the target like this; this will
4297	remove the extended remote target from the target stack,
4298	and the next time the user says "run" it'll fail.
4299
4300	FIXME: What is the right thing to do here? */
4301	#if 0
4302	remote_mourn_1 (&extended_remote_ops);
4303	#endif
4304	}
4305
4306	/* Worker function for remote_mourn. */
4307	static void
4308	remote_mourn_1 (struct target_ops *target)
4309	{
4310	unpush_target (target);
4311	generic_mourn_inferior ();
4312	}
4313
4314	/* In the extended protocol we want to be able to do things like
4315	"run" and have them basically work as expected. So we need
4316	a special create_inferior function.
4317
4318	FIXME: One day add support for changing the exec file
4319	we're debugging, arguments and an environment. */
4320
4321	static void
4322	extended_remote_create_inferior (char exec_file, char args, char **env,
4323	int from_tty)
4324	{
4325	/* Rip out the breakpoints; we'll reinsert them after restarting
4326	the remote server. */
4327	remove_breakpoints ();
4328
4329	/* Now restart the remote server. */
4330	extended_remote_restart ();
4331
4332	/* Now put the breakpoints back in. This way we're safe if the
4333	restart function works via a unix fork on the remote side. */
4334	insert_breakpoints ();
4335
4336	/* Clean up from the last time we were running. */
4337	clear_proceed_status ();
4338
4339	/* Let the remote process run. */
4340	proceed (-1, TARGET_SIGNAL_0, 0);
4341	}
4342
4343	/* Async version of extended_remote_create_inferior. */
4344	static void
4345	extended_remote_async_create_inferior (char exec_file, char args, char **env,
4346	int from_tty)
4347	{
4348	/* Rip out the breakpoints; we'll reinsert them after restarting
4349	the remote server. */
4350	remove_breakpoints ();
4351
4352	/* If running asynchronously, register the target file descriptor
4353	with the event loop. */
4354	if (target_can_async_p ()(current_target.to_can_async_p ()))
4355	target_async (inferior_event_handler, 0)(current_target.to_async((inferior_event_handler), (0)));
4356
4357	/* Now restart the remote server. */
4358	extended_remote_restart ();
4359
4360	/* Now put the breakpoints back in. This way we're safe if the
4361	restart function works via a unix fork on the remote side. */
4362	insert_breakpoints ();
4363
4364	/* Clean up from the last time we were running. */
4365	clear_proceed_status ();
4366
4367	/* Let the remote process run. */
4368	proceed (-1, TARGET_SIGNAL_0, 0);
4369	}
4370
4371
4372	/* On some machines, e.g. 68k, we may use a different breakpoint
4373	instruction than other targets; in those use
4374	DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
4375	Also, bi-endian targets may define
4376	DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
4377	DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
4378	just call the standard routines that are in mem-break.c. */
4379
4380	/* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
4381	target should use an identical BREAKPOINT_FROM_PC. As for native,
4382	the ARCH-OS-tdep.c code can override the default. */
4383
4384	#if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
4385	#define DEPRECATED_REMOTE_BREAKPOINT
4386	#endif
4387
4388	#ifdef DEPRECATED_REMOTE_BREAKPOINT
4389
4390	/* If the target isn't bi-endian, just pretend it is. */
4391	#if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
4392	#define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4393	#define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4394	#endif
4395
4396	static unsigned char big_break_insn[] = DEPRECATED_BIG_REMOTE_BREAKPOINT;
4397	static unsigned char little_break_insn[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT;
4398
4399	#endif /* DEPRECATED_REMOTE_BREAKPOINT */
4400
4401	/* Insert a breakpoint on targets that don't have any better
4402	breakpoint support. We read the contents of the target location
4403	and stash it, then overwrite it with a breakpoint instruction.
4404	ADDR is the target location in the target machine. CONTENTS_CACHE
4405	is a pointer to memory allocated for saving the target contents.
4406	It is guaranteed by the caller to be long enough to save the number
4407	of bytes returned by BREAKPOINT_FROM_PC. */
4408
4409	static int
4410	remote_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
4411	{
4412	struct remote_state *rs = get_remote_state ();
4413	#ifdef DEPRECATED_REMOTE_BREAKPOINT
4414	int val;
4415	#endif
4416	int bp_size;
4417
4418	/* Try the "Z" s/w breakpoint packet if it is not already disabled.
4419	If it succeeds, then set the support to PACKET_ENABLE. If it
4420	fails, and the user has explicitly requested the Z support then
4421	report an error, otherwise, mark it disabled and go on. */
4422
4423	if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4424	{
4425	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4426	char *p = buf;
4427
4428	addr = remote_address_masked (addr);
4429	*(p++) = 'Z';
4430	*(p++) = '0';
4431	*(p++) = ',';
4432	p += hexnumstr (p, (ULONGESTunsigned long) addr);
4433	BREAKPOINT_FROM_PC (&addr, &bp_size)(gdbarch_breakpoint_from_pc (current_gdbarch, &addr, & bp_size));
4434	sprintf (p, ",%d", bp_size);
4435
4436	putpkt (buf);
4437	getpkt (buf, (rs->remote_packet_size), 0);
4438
4439	switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_SOFTWARE_BP]))
4440	{
4441	case PACKET_ERROR:
4442	return -1;
4443	case PACKET_OK:
4444	return 0;
4445	case PACKET_UNKNOWN:
4446	break;
4447	}
4448	}
4449
4450	#ifdef DEPRECATED_REMOTE_BREAKPOINT
4451	val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
4452
4453	if (val == 0)
4454	{
4455	if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG)
4456	val = target_write_memory (addr, (char *) big_break_insn,
4457	sizeof big_break_insn);
4458	else
4459	val = target_write_memory (addr, (char *) little_break_insn,
4460	sizeof little_break_insn);
4461	}
4462
4463	return val;
4464	#else
4465	return memory_insert_breakpoint (addr, contents_cache);
4466	#endif /* DEPRECATED_REMOTE_BREAKPOINT */
4467	}
4468
4469	static int
4470	remote_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
4471	{
4472	struct remote_state *rs = get_remote_state ();
4473	int bp_size;
4474
4475	if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4476	{
4477	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4478	char *p = buf;
4479
4480	*(p++) = 'z';
4481	*(p++) = '0';
4482	*(p++) = ',';
4483
4484	addr = remote_address_masked (addr);
4485	p += hexnumstr (p, (ULONGESTunsigned long) addr);
4486	BREAKPOINT_FROM_PC (&addr, &bp_size)(gdbarch_breakpoint_from_pc (current_gdbarch, &addr, & bp_size));
4487	sprintf (p, ",%d", bp_size);
4488
4489	putpkt (buf);
4490	getpkt (buf, (rs->remote_packet_size), 0);
4491
4492	return (buf[0] == 'E');
4493	}
4494
4495	#ifdef DEPRECATED_REMOTE_BREAKPOINT
4496	return target_write_memory (addr, contents_cache, sizeof big_break_insn);
4497	#else
4498	return memory_remove_breakpoint (addr, contents_cache);
4499	#endif /* DEPRECATED_REMOTE_BREAKPOINT */
4500	}
4501
4502	static int
4503	watchpoint_to_Z_packet (int type)
4504	{
4505	switch (type)
4506	{
4507	case hw_write:
4508	return 2;
4509	break;
4510	case hw_read:
4511	return 3;
4512	break;
4513	case hw_access:
4514	return 4;
4515	break;
4516	default:
4517	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__4517,
4518	"hw_bp_to_z: bad watchpoint type %d", type);
4519	}
4520	}
4521
4522	static int
4523	remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
4524	{
4525	struct remote_state *rs = get_remote_state ();
4526	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4527	char *p;
4528	enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4529
4530	if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4531	error ("Can't set hardware watchpoints without the '%s' (%s) packet\n",
4532	remote_protocol_Z[packet].name,
4533	remote_protocol_Z[packet].title);
4534
4535	sprintf (buf, "Z%x,", packet);
4536	p = strchr (buf, '\0');
4537	addr = remote_address_masked (addr);
4538	p += hexnumstr (p, (ULONGESTunsigned long) addr);
4539	sprintf (p, ",%x", len);
4540
4541	putpkt (buf);
4542	getpkt (buf, (rs->remote_packet_size), 0);
4543
4544	switch (packet_ok (buf, &remote_protocol_Z[packet]))
4545	{
4546	case PACKET_ERROR:
4547	case PACKET_UNKNOWN:
4548	return -1;
4549	case PACKET_OK:
4550	return 0;
4551	}
4552	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__4552,
4553	"remote_insert_watchpoint: reached end of function");
4554	}
4555
4556
4557	static int
4558	remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
4559	{
4560	struct remote_state *rs = get_remote_state ();
4561	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4562	char *p;
4563	enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4564
4565	if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4566	error ("Can't clear hardware watchpoints without the '%s' (%s) packet\n",
4567	remote_protocol_Z[packet].name,
4568	remote_protocol_Z[packet].title);
4569
4570	sprintf (buf, "z%x,", packet);
4571	p = strchr (buf, '\0');
4572	addr = remote_address_masked (addr);
4573	p += hexnumstr (p, (ULONGESTunsigned long) addr);
4574	sprintf (p, ",%x", len);
4575	putpkt (buf);
4576	getpkt (buf, (rs->remote_packet_size), 0);
4577
4578	switch (packet_ok (buf, &remote_protocol_Z[packet]))
4579	{
4580	case PACKET_ERROR:
4581	case PACKET_UNKNOWN:
4582	return -1;
4583	case PACKET_OK:
4584	return 0;
4585	}
4586	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__4586,
4587	"remote_remove_watchpoint: reached end of function");
4588	}
4589
4590
4591	int remote_hw_watchpoint_limit = -1;
4592	int remote_hw_breakpoint_limit = -1;
4593
4594	static int
4595	remote_check_watch_resources (int type, int cnt, int ot)
4596	{
4597	if (type == bp_hardware_breakpoint)
4598	{
4599	if (remote_hw_breakpoint_limit == 0)
4600	return 0;
4601	else if (remote_hw_breakpoint_limit < 0)
4602	return 1;
4603	else if (cnt <= remote_hw_breakpoint_limit)
4604	return 1;
4605	}
4606	else
4607	{
4608	if (remote_hw_watchpoint_limit == 0)
4609	return 0;
4610	else if (remote_hw_watchpoint_limit < 0)
4611	return 1;
4612	else if (ot)
4613	return -1;
4614	else if (cnt <= remote_hw_watchpoint_limit)
4615	return 1;
4616	}
4617	return -1;
4618	}
4619
4620	static int
4621	remote_stopped_by_watchpoint (void)
4622	{
4623	return remote_stopped_by_watchpoint_p;
4624	}
4625
4626	extern int stepped_after_stopped_by_watchpoint;
4627
4628	static int
4629	remote_stopped_data_address (struct target_ops target, CORE_ADDR addr_p)
4630	{
4631	int rc = 0;
4632	if (remote_stopped_by_watchpoint ()
4633	\|\| stepped_after_stopped_by_watchpoint)
4634	{
4635	*addr_p = remote_watch_data_address;
4636	rc = 1;
4637	}
4638
4639	return rc;
4640	}
4641
4642
4643	static int
4644	remote_insert_hw_breakpoint (CORE_ADDR addr, char *shadow)
4645	{
4646	int len = 0;
4647	struct remote_state *rs = get_remote_state ();
4648	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4649	char *p = buf;
4650
4651	/* The length field should be set to the size of a breakpoint
4652	instruction. */
4653
4654	BREAKPOINT_FROM_PC (&addr, &len)(gdbarch_breakpoint_from_pc (current_gdbarch, &addr, & len));
4655
4656	if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4657	error ("Can't set hardware breakpoint without the '%s' (%s) packet\n",
4658	remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4659	remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4660
4661	*(p++) = 'Z';
4662	*(p++) = '1';
4663	*(p++) = ',';
4664
4665	addr = remote_address_masked (addr);
4666	p += hexnumstr (p, (ULONGESTunsigned long) addr);
4667	sprintf (p, ",%x", len);
4668
4669	putpkt (buf);
4670	getpkt (buf, (rs->remote_packet_size), 0);
4671
4672	switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4673	{
4674	case PACKET_ERROR:
4675	case PACKET_UNKNOWN:
4676	return -1;
4677	case PACKET_OK:
4678	return 0;
4679	}
4680	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__4680,
4681	"remote_insert_hw_breakpoint: reached end of function");
4682	}
4683
4684
4685	static int
4686	remote_remove_hw_breakpoint (CORE_ADDR addr, char *shadow)
4687	{
4688	int len;
4689	struct remote_state *rs = get_remote_state ();
4690	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4691	char *p = buf;
4692
4693	/* The length field should be set to the size of a breakpoint
4694	instruction. */
4695
4696	BREAKPOINT_FROM_PC (&addr, &len)(gdbarch_breakpoint_from_pc (current_gdbarch, &addr, & len));
4697
4698	if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4699	error ("Can't clear hardware breakpoint without the '%s' (%s) packet\n",
4700	remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4701	remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4702
4703	*(p++) = 'z';
4704	*(p++) = '1';
4705	*(p++) = ',';
4706
4707	addr = remote_address_masked (addr);
4708	p += hexnumstr (p, (ULONGESTunsigned long) addr);
4709	sprintf (p, ",%x", len);
4710
4711	putpkt(buf);
4712	getpkt (buf, (rs->remote_packet_size), 0);
4713
4714	switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4715	{
4716	case PACKET_ERROR:
4717	case PACKET_UNKNOWN:
4718	return -1;
4719	case PACKET_OK:
4720	return 0;
4721	}
4722	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__4722,
4723	"remote_remove_hw_breakpoint: reached end of function");
4724	}
4725
4726	/* Some targets are only capable of doing downloads, and afterwards
4727	they switch to the remote serial protocol. This function provides
4728	a clean way to get from the download target to the remote target.
4729	It's basically just a wrapper so that we don't have to expose any
4730	of the internal workings of remote.c.
4731
4732	Prior to calling this routine, you should shutdown the current
4733	target code, else you will get the "A program is being debugged
4734	already..." message. Usually a call to pop_target() suffices. */
4735
4736	void
4737	push_remote_target (char *name, int from_tty)
4738	{
4739	printf_filtered ("Switching to remote protocol\n");
4740	remote_open (name, from_tty);
4741	}
4742
4743	/* Table used by the crc32 function to calcuate the checksum. */
4744
4745	static unsigned long crc32_table[256] =
4746	{0, 0};
4747
4748	static unsigned long
4749	crc32 (unsigned char *buf, int len, unsigned int crc)
4750	{
4751	if (!crc32_table[1])
4752	{
4753	/* Initialize the CRC table and the decoding table. */
4754	int i, j;
4755	unsigned int c;
4756
4757	for (i = 0; i < 256; i++)
4758	{
4759	for (c = i << 24, j = 8; j > 0; --j)
4760	c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
4761	crc32_table[i] = c;
4762	}
4763	}
4764
4765	while (len--)
4766	{
4767	crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
4768	buf++;
4769	}
4770	return crc;
4771	}
4772
4773	/* compare-sections command
4774
4775	With no arguments, compares each loadable section in the exec bfd
4776	with the same memory range on the target, and reports mismatches.
4777	Useful for verifying the image on the target against the exec file.
4778	Depends on the target understanding the new "qCRC:" request. */
4779
4780	/* FIXME: cagney/1999-10-26: This command should be broken down into a
4781	target method (target verify memory) and generic version of the
4782	actual command. This will allow other high-level code (especially
4783	generic_load()) to make use of this target functionality. */
4784
4785	static void
4786	compare_sections_command (char *args, int from_tty)
4787	{
4788	struct remote_state *rs = get_remote_state ();
4789	asection *s;
4790	unsigned long host_crc, target_crc;
4791	extern bfd *exec_bfd;
4792	struct cleanup *old_chain;
4793	char *tmp;
4794	char *sectdata;
4795	const char *sectname;
4796	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4797	bfd_size_type size;
4798	bfd_vma lma;
4799	int matched = 0;
4800	int mismatched = 0;
4801
4802	if (!exec_bfd)
4803	error ("command cannot be used without an exec file");
4804	if (!current_target.to_shortname \|\|
4805	strcmp (current_target.to_shortname, "remote") != 0)
4806	error ("command can only be used with remote target");
4807
4808	for (s = exec_bfd->sections; s; s = s->next)
4809	{
4810	if (!(s->flags & SEC_LOAD0x002))
4811	continue; /* skip non-loadable section */
4812
4813	size = bfd_get_section_size (s)((s)->_raw_size);
4814	if (size == 0)
4815	continue; /* skip zero-length section */
4816
4817	sectname = bfd_get_section_name (exec_bfd, s)((s)->name + 0);
4818	if (args && strcmp (args, sectname) != 0)
4819	continue; /* not the section selected by user */
4820
4821	matched = 1; /* do this section */
4822	lma = s->lma;
4823	/* FIXME: assumes lma can fit into long */
4824	sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
4825	putpkt (buf);
4826
4827	/* be clever; compute the host_crc before waiting for target reply */
4828	sectdata = xmalloc (size);
4829	old_chain = make_cleanup (xfree, sectdata);
4830	bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
4831	host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
4832
4833	getpkt (buf, (rs->remote_packet_size), 0);
4834	if (buf[0] == 'E')
4835	error ("target memory fault, section %s, range 0x%s -- 0x%s",
4836	sectname, paddr (lma), paddr (lma + size));
4837	if (buf[0] != 'C')
4838	error ("remote target does not support this operation");
4839
4840	for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
4841	target_crc = target_crc * 16 + fromhex (*tmp);
4842
4843	printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
4844	sectname, paddr (lma), paddr (lma + size));
4845	if (host_crc == target_crc)
4846	printf_filtered ("matched.\n");
4847	else
4848	{
4849	printf_filtered ("MIS-MATCHED!\n");
4850	mismatched++;
4851	}
4852
4853	do_cleanups (old_chain);
4854	}
4855	if (mismatched > 0)
4856	warning ("One or more sections of the remote executable does not match\n\
4857	the loaded file\n");
4858	if (args && !matched)
4859	printf_filtered ("No loaded section named '%s'.\n", args);
4860	}
4861
4862	static LONGESTlong
4863	remote_xfer_partial (struct target_ops *ops, enum target_object object,
4864	const char annex, void readbuf, const void *writebuf,
4865	ULONGESTunsigned long offset, LONGESTlong len)
4866	{
4867	struct remote_state *rs = get_remote_state ();
4868	int i;
4869	char *buf2 = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
4870	char *p2 = &buf2[0];
4871	char query_type;
4872
4873	/* Handle memory using remote_xfer_memory. */
4874	if (object == TARGET_OBJECT_MEMORY)
4875	{
4876	int xfered;
4877	errno(*__errno()) = 0;
4878
4879	if (writebuf != NULL((void*)0))
4880	{
4881	void *buffer = xmalloc (len);
4882	struct cleanup *cleanup = make_cleanup (xfree, buffer);
4883	memcpy (buffer, writebuf, len);
4884	xfered = remote_xfer_memory (offset, buffer, len, 1, NULL((void*)0), ops);
4885	do_cleanups (cleanup);
4886	}
4887	else
4888	xfered = remote_xfer_memory (offset, readbuf, len, 0, NULL((void*)0), ops);
4889
4890	if (xfered > 0)
4891	return xfered;
4892	else if (xfered == 0 && errno(*__errno()) == 0)
4893	return 0;
4894	else
4895	return -1;
4896	}
4897
4898	/* Only handle reads. */
4899	if (writebuf != NULL((void)0) \|\| readbuf == NULL((void)0))
4900	return -1;
4901
4902	/* Map pre-existing objects onto letters. DO NOT do this for new
4903	objects!!! Instead specify new query packets. */
4904	switch (object)
4905	{
4906	case TARGET_OBJECT_KOD:
4907	query_type = 'K';
4908	break;
4909	case TARGET_OBJECT_AVR:
4910	query_type = 'R';
4911	break;
4912
4913	case TARGET_OBJECT_AUXV:
4914	if (remote_protocol_qPart_auxv.support != PACKET_DISABLE)
4915	{
4916	unsigned int total = 0;
4917	while (len > 0)
4918	{
4919	LONGESTlong n = min ((rs->remote_packet_size - 2) / 2, len)(((rs->remote_packet_size - 2) / 2) < (len) ? ((rs-> remote_packet_size - 2) / 2) : (len));
4920	snprintf (buf2, rs->remote_packet_size,
4921	"qPart:auxv:read::%s,%s",
4922	phex_nz (offset, sizeof offset),
4923	phex_nz (n, sizeof n));
4924	i = putpkt (buf2);
4925	if (i < 0)
4926	return total > 0 ? total : i;
4927	buf2[0] = '\0';
4928	getpkt (buf2, rs->remote_packet_size, 0);
4929	if (packet_ok (buf2, &remote_protocol_qPart_auxv) != PACKET_OK)
4930	return total > 0 ? total : -1;
4931	if (buf2[0] == 'O' && buf2[1] == 'K' && buf2[2] == '\0')
4932	break; /* Got EOF indicator. */
4933	/* Got some data. */
4934	i = hex2bin (buf2, readbuf, len);
4935	if (i > 0)
4936	{
4937	readbuf = (void ) ((char ) readbuf + i);
4938	offset += i;
4939	len -= i;
4940	total += i;
4941	}
4942	}
4943	return total;
4944	}
4945	return -1;
4946
4947	default:
4948	return -1;
4949	}
4950
4951	/* Note: a zero OFFSET and LEN can be used to query the minimum
4952	buffer size. */
4953	if (offset == 0 && len == 0)
4954	return (rs->remote_packet_size);
4955	/* Minimum outbuf size is (rs->remote_packet_size) - if bufsiz is
4956	not large enough let the caller. */
4957	if (len < (rs->remote_packet_size))
4958	return -1;
4959	len = rs->remote_packet_size;
4960
4961	/* except for querying the minimum buffer size, target must be open */
4962	if (!remote_desc)
4963	error ("remote query is only available after target open");
4964
4965	gdb_assert (annex != NULL)((void) ((annex != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 4965, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "annex != NULL" ), 0)));
4966	gdb_assert (readbuf != NULL)((void) ((readbuf != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 4966, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "readbuf != NULL" ), 0)));
4967
4968	*p2++ = 'q';
4969	*p2++ = query_type;
4970
4971	/* we used one buffer char for the remote protocol q command and another
4972	for the query type. As the remote protocol encapsulation uses 4 chars
4973	plus one extra in case we are debugging (remote_debug),
4974	we have PBUFZIZ - 7 left to pack the query string */
4975	i = 0;
4976	while (annex[i] && (i < ((rs->remote_packet_size) - 8)))
4977	{
4978	/* Bad caller may have sent forbidden characters. */
4979	gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#')((void) ((isprint (annex[i]) && annex[i] != '$' && annex[i] != '#') ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 4979, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "isprint (annex[i]) && annex[i] != '$' && annex[i] != '#'" ), 0)));
4980	*p2++ = annex[i];
4981	i++;
4982	}
4983	*p2 = '\0';
4984	gdb_assert (annex[i] == '\0')((void) ((annex[i] == '\0') ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/remote.c" , 4984, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "annex[i] == '\\0'" ), 0)));
4985
4986	i = putpkt (buf2);
4987	if (i < 0)
4988	return i;
4989
4990	getpkt (readbuf, len, 0);
4991
4992	return strlen (readbuf);
4993	}
4994
4995	static void
4996	remote_rcmd (char *command,
4997	struct ui_file *outbuf)
4998	{
4999	struct remote_state *rs = get_remote_state ();
5000	int i;
5001	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
5002	char *p = buf;
	Value stored to 'p' during its initialization is never read
5003
5004	if (!remote_desc)
5005	error ("remote rcmd is only available after target open");
5006
5007	/* Send a NULL command across as an empty command */
5008	if (command == NULL((void*)0))
5009	command = "";
5010
5011	/* The query prefix */
5012	strcpy (buf, "qRcmd,");
5013	p = strchr (buf, '\0');
5014
5015	if ((strlen (buf) + strlen (command) * 2 + 8/misc/) > (rs->remote_packet_size))
5016	error ("\"monitor\" command ``%s'' is too long\n", command);
5017
5018	/* Encode the actual command */
5019	bin2hex (command, p, 0);
5020
5021	if (putpkt (buf) < 0)
5022	error ("Communication problem with target\n");
5023
5024	/* get/display the response */
5025	while (1)
5026	{
5027	/* XXX - see also tracepoint.c:remote_get_noisy_reply() */
5028	buf[0] = '\0';
5029	getpkt (buf, (rs->remote_packet_size), 0);
5030	if (buf[0] == '\0')
5031	error ("Target does not support this command\n");
5032	if (buf[0] == 'O' && buf[1] != 'K')
5033	{
5034	remote_console_output (buf + 1); /* 'O' message from stub */
5035	continue;
5036	}
5037	if (strcmp (buf, "OK") == 0)
5038	break;
5039	if (strlen (buf) == 3 && buf[0] == 'E'
5040	&& isdigit (buf[1]) && isdigit (buf[2]))
5041	{
5042	error ("Protocol error with Rcmd");
5043	}
5044	for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
5045	{
5046	char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
5047	fputc_unfiltered (c, outbuf);
5048	}
5049	break;
5050	}
5051	}
5052
5053	static void
5054	packet_command (char *args, int from_tty)
5055	{
5056	struct remote_state *rs = get_remote_state ();
5057	char *buf = alloca (rs->remote_packet_size)__builtin_alloca(rs->remote_packet_size);
5058
5059	if (!remote_desc)
5060	error ("command can only be used with remote target");
5061
5062	if (!args)
5063	error ("remote-packet command requires packet text as argument");
5064
5065	puts_filtered ("sending: ");
5066	print_packet (args);
5067	puts_filtered ("\n");
5068	putpkt (args);
5069
5070	getpkt (buf, (rs->remote_packet_size), 0);
5071	puts_filtered ("received: ");
5072	print_packet (buf);
5073	puts_filtered ("\n");
5074	}
5075
5076	#if 0
5077	/* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
5078
5079	static void display_thread_info (struct gdb_ext_thread_info *info);
5080
5081	static void threadset_test_cmd (char *cmd, int tty);
5082
5083	static void threadalive_test (char *cmd, int tty);
5084
5085	static void threadlist_test_cmd (char *cmd, int tty);
5086
5087	int get_and_display_threadinfo (threadref * ref);
5088
5089	static void threadinfo_test_cmd (char *cmd, int tty);
5090
5091	static int thread_display_step (threadref * ref, void *context);
5092
5093	static void threadlist_update_test_cmd (char *cmd, int tty);
5094
5095	static void init_remote_threadtests (void);
5096
5097	#define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid */
5098
5099	static void
5100	threadset_test_cmd (char *cmd, int tty)
5101	{
5102	int sample_thread = SAMPLE_THREAD;
5103
5104	printf_filtered ("Remote threadset test\n");
5105	set_thread (sample_thread, 1);
5106	}
5107
5108
5109	static void
5110	threadalive_test (char *cmd, int tty)
5111	{
5112	int sample_thread = SAMPLE_THREAD;
5113
5114	if (remote_thread_alive (pid_to_ptid (sample_thread)))
5115	printf_filtered ("PASS: Thread alive test\n");
5116	else
5117	printf_filtered ("FAIL: Thread alive test\n");
5118	}
5119
5120	void output_threadid (char title, threadref ref);
5121
5122	void
5123	output_threadid (char title, threadref ref)
5124	{
5125	char hexid[20];
5126
5127	pack_threadid (&hexid[0], ref); /* Convert threead id into hex */
5128	hexid[16] = 0;
5129	printf_filtered ("%s %s\n", title, (&hexid[0]));
5130	}
5131
5132	static void
5133	threadlist_test_cmd (char *cmd, int tty)
5134	{
5135	int startflag = 1;
5136	threadref nextthread;
5137	int done, result_count;
5138	threadref threadlist[3];
5139
5140	printf_filtered ("Remote Threadlist test\n");
5141	if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
5142	&result_count, &threadlist[0]))
5143	printf_filtered ("FAIL: threadlist test\n");
5144	else
5145	{
5146	threadref *scan = threadlist;
5147	threadref *limit = scan + result_count;
5148
5149	while (scan < limit)
5150	output_threadid (" thread ", scan++);
5151	}
5152	}
5153
5154	void
5155	display_thread_info (struct gdb_ext_thread_info *info)
5156	{
5157	output_threadid ("Threadid: ", &info->threadid);
5158	printf_filtered ("Name: %s\n ", info->shortname);
5159	printf_filtered ("State: %s\n", info->display);
5160	printf_filtered ("other: %s\n\n", info->more_display);
5161	}
5162
5163	int
5164	get_and_display_threadinfo (threadref *ref)
5165	{
5166	int result;
5167	int set;
5168	struct gdb_ext_thread_info threadinfo;
5169
5170	set = TAG_THREADID1 \| TAG_EXISTS2 \| TAG_THREADNAME8
5171	\| TAG_MOREDISPLAY16 \| TAG_DISPLAY4;
5172	if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
5173	display_thread_info (&threadinfo);
5174	return result;
5175	}
5176
5177	static void
5178	threadinfo_test_cmd (char *cmd, int tty)
5179	{
5180	int athread = SAMPLE_THREAD;
5181	threadref thread;
5182	int set;
5183
5184	int_to_threadref (&thread, athread);
5185	printf_filtered ("Remote Threadinfo test\n");
5186	if (!get_and_display_threadinfo (&thread))
5187	printf_filtered ("FAIL cannot get thread info\n");
5188	}
5189
5190	static int
5191	thread_display_step (threadref ref, void context)
5192	{
5193	/* output_threadid(" threadstep ",ref); // simple test */
5194	return get_and_display_threadinfo (ref);
5195	}
5196
5197	static void
5198	threadlist_update_test_cmd (char *cmd, int tty)
5199	{
5200	printf_filtered ("Remote Threadlist update test\n");
5201	remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS1000);
5202	}
5203
5204	static void
5205	init_remote_threadtests (void)
5206	{
5207	add_com ("tlist", class_obscure, threadlist_test_cmd,
5208	"Fetch and print the remote list of thread identifiers, one pkt only");
5209	add_com ("tinfo", class_obscure, threadinfo_test_cmd,
5210	"Fetch and display info about one thread");
5211	add_com ("tset", class_obscure, threadset_test_cmd,
5212	"Test setting to a different thread");
5213	add_com ("tupd", class_obscure, threadlist_update_test_cmd,
5214	"Iterate through updating all remote thread info");
5215	add_com ("talive", class_obscure, threadalive_test,
5216	" Remote thread alive test ");
5217	}
5218
5219	#endif /* 0 */
5220
5221	/* Convert a thread ID to a string. Returns the string in a static
5222	buffer. */
5223
5224	static char *
5225	remote_pid_to_str (ptid_t ptid)
5226	{
5227	static char buf[30];
5228
5229	sprintf (buf, "Thread %d", PIDGET (ptid)(ptid_get_pid (ptid)));
5230	return buf;
5231	}
5232
5233	static void
5234	init_remote_ops (void)
5235	{
5236	remote_ops.to_shortname = "remote";
5237	remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
5238	remote_ops.to_doc =
5239	"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5240	Specify the serial device it is connected to\n\
5241	(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5242	remote_ops.to_open = remote_open;
5243	remote_ops.to_close = remote_close;
5244	remote_ops.to_detach = remote_detach;
5245	remote_ops.to_disconnect = remote_disconnect;
5246	remote_ops.to_resume = remote_resume;
5247	remote_ops.to_wait = remote_wait;
5248	remote_ops.to_fetch_registers = remote_fetch_registers;
5249	remote_ops.to_store_registers = remote_store_registers;
5250	remote_ops.to_prepare_to_store = remote_prepare_to_store;
5251	remote_ops.deprecated_xfer_memory = remote_xfer_memory;
5252	remote_ops.to_files_info = remote_files_info;
5253	remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
5254	remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
5255	remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5256	remote_ops.to_stopped_data_address = remote_stopped_data_address;
5257	remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5258	remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5259	remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5260	remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
5261	remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
5262	remote_ops.to_kill = remote_kill;
5263	remote_ops.to_load = generic_load;
5264	remote_ops.to_mourn_inferior = remote_mourn;
5265	remote_ops.to_thread_alive = remote_thread_alive;
5266	remote_ops.to_find_new_threads = remote_threads_info;
5267	remote_ops.to_pid_to_str = remote_pid_to_str;
5268	remote_ops.to_extra_thread_info = remote_threads_extra_info;
5269	remote_ops.to_stop = remote_stop;
5270	remote_ops.to_xfer_partial = remote_xfer_partial;
5271	remote_ops.to_rcmd = remote_rcmd;
5272	remote_ops.to_stratum = process_stratum;
5273	remote_ops.to_has_all_memory = 1;
5274	remote_ops.to_has_memory = 1;
5275	remote_ops.to_has_stack = 1;
5276	remote_ops.to_has_registers = 1;
5277	remote_ops.to_has_execution = 1;
5278	remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5279	remote_ops.to_magic = OPS_MAGIC3840;
5280	}
5281
5282	/* Set up the extended remote vector by making a copy of the standard
5283	remote vector and adding to it. */
5284
5285	static void
5286	init_extended_remote_ops (void)
5287	{
5288	extended_remote_ops = remote_ops;
5289
5290	extended_remote_ops.to_shortname = "extended-remote";
5291	extended_remote_ops.to_longname =
5292	"Extended remote serial target in gdb-specific protocol";
5293	extended_remote_ops.to_doc =
5294	"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5295	Specify the serial device it is connected to (e.g. /dev/ttya).",
5296	extended_remote_ops.to_open = extended_remote_open;
5297	extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
5298	extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
5299	}
5300
5301	static int
5302	remote_can_async_p (void)
5303	{
5304	/* We're async whenever the serial device is. */
5305	return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
5306	}
5307
5308	static int
5309	remote_is_async_p (void)
5310	{
5311	/* We're async whenever the serial device is. */
5312	return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
5313	}
5314
5315	/* Pass the SERIAL event on and up to the client. One day this code
5316	will be able to delay notifying the client of an event until the
5317	point where an entire packet has been received. */
5318
5319	static void (async_client_callback) (enum inferior_event_type event_type, void context);
5320	static void *async_client_context;
5321	static serial_event_ftype remote_async_serial_handler;
5322
5323	static void
5324	remote_async_serial_handler (struct serial scb, void context)
5325	{
5326	/* Don't propogate error information up to the client. Instead let
5327	the client find out about the error by querying the target. */
5328	async_client_callback (INF_REG_EVENT, async_client_context);
5329	}
5330
5331	static void
5332	remote_async (void (callback) (enum inferior_event_type event_type, void context), void *context)
5333	{
5334	if (current_target.to_async_mask_value == 0)
5335	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/remote.c", __LINE__5335,
5336	"Calling remote_async when async is masked");
5337
5338	if (callback != NULL((void*)0))
5339	{
5340	serial_async (remote_desc, remote_async_serial_handler, NULL((void*)0));
5341	async_client_callback = callback;
5342	async_client_context = context;
5343	}
5344	else
5345	serial_async (remote_desc, NULL((void)0), NULL((void)0));
5346	}
5347
5348	/* Target async and target extended-async.
5349
5350	This are temporary targets, until it is all tested. Eventually
5351	async support will be incorporated int the usual 'remote'
5352	target. */
5353
5354	static void
5355	init_remote_async_ops (void)
5356	{
5357	remote_async_ops.to_shortname = "async";
5358	remote_async_ops.to_longname = "Remote serial target in async version of the gdb-specific protocol";
5359	remote_async_ops.to_doc =
5360	"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5361	Specify the serial device it is connected to (e.g. /dev/ttya).";
5362	remote_async_ops.to_open = remote_async_open;
5363	remote_async_ops.to_close = remote_close;
5364	remote_async_ops.to_detach = remote_detach;
5365	remote_async_ops.to_disconnect = remote_disconnect;
5366	remote_async_ops.to_resume = remote_async_resume;
5367	remote_async_ops.to_wait = remote_async_wait;
5368	remote_async_ops.to_fetch_registers = remote_fetch_registers;
5369	remote_async_ops.to_store_registers = remote_store_registers;
5370	remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
5371	remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
5372	remote_async_ops.to_files_info = remote_files_info;
5373	remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
5374	remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
5375	remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5376	remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5377	remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5378	remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
5379	remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
5380	remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5381	remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
5382	remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
5383	remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
5384	remote_async_ops.to_kill = remote_async_kill;
5385	remote_async_ops.to_load = generic_load;
5386	remote_async_ops.to_mourn_inferior = remote_async_mourn;
5387	remote_async_ops.to_thread_alive = remote_thread_alive;
5388	remote_async_ops.to_find_new_threads = remote_threads_info;
5389	remote_async_ops.to_pid_to_str = remote_pid_to_str;
5390	remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
5391	remote_async_ops.to_stop = remote_stop;
5392	remote_async_ops.to_xfer_partial = remote_xfer_partial;
5393	remote_async_ops.to_rcmd = remote_rcmd;
5394	remote_async_ops.to_stratum = process_stratum;
5395	remote_async_ops.to_has_all_memory = 1;
5396	remote_async_ops.to_has_memory = 1;
5397	remote_async_ops.to_has_stack = 1;
5398	remote_async_ops.to_has_registers = 1;
5399	remote_async_ops.to_has_execution = 1;
5400	remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5401	remote_async_ops.to_can_async_p = remote_can_async_p;
5402	remote_async_ops.to_is_async_p = remote_is_async_p;
5403	remote_async_ops.to_async = remote_async;
5404	remote_async_ops.to_async_mask_value = 1;
5405	remote_async_ops.to_magic = OPS_MAGIC3840;
5406	}
5407
5408	/* Set up the async extended remote vector by making a copy of the standard
5409	remote vector and adding to it. */
5410
5411	static void
5412	init_extended_async_remote_ops (void)
5413	{
5414	extended_async_remote_ops = remote_async_ops;
5415
5416	extended_async_remote_ops.to_shortname = "extended-async";
5417	extended_async_remote_ops.to_longname =
5418	"Extended remote serial target in async gdb-specific protocol";
5419	extended_async_remote_ops.to_doc =
5420	"Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5421	Specify the serial device it is connected to (e.g. /dev/ttya).",
5422	extended_async_remote_ops.to_open = extended_remote_async_open;
5423	extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
5424	extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
5425	}
5426
5427	static void
5428	set_remote_cmd (char *args, int from_tty)
5429	{
5430	}
5431
5432	static void
5433	show_remote_cmd (char *args, int from_tty)
5434	{
5435	/* FIXME: cagney/2002-06-15: This function should iterate over
5436	remote_show_cmdlist for a list of sub commands to show. */
5437	show_remote_protocol_Z_packet_cmd (args, from_tty, NULL((void*)0));
5438	show_remote_protocol_P_packet_cmd (args, from_tty, NULL((void*)0));
5439	show_remote_protocol_p_packet_cmd (args, from_tty, NULL((void*)0));
5440	show_remote_protocol_qSymbol_packet_cmd (args, from_tty, NULL((void*)0));
5441	show_remote_protocol_vcont_packet_cmd (args, from_tty, NULL((void*)0));
5442	show_remote_protocol_binary_download_cmd (args, from_tty, NULL((void*)0));
5443	show_remote_protocol_qPart_auxv_packet_cmd (args, from_tty, NULL((void*)0));
5444	}
5445
5446	static void
5447	build_remote_gdbarch_data (void)
5448	{
5449	remote_address_size = TARGET_ADDR_BIT(gdbarch_addr_bit (current_gdbarch));
5450	}
5451
5452	/* Saved pointer to previous owner of the new_objfile event. */
5453	static void (remote_new_objfile_chain) (struct objfile );
5454
5455	/* Function to be called whenever a new objfile (shlib) is detected. */
5456	static void
5457	remote_new_objfile (struct objfile *objfile)
5458	{
5459	if (remote_desc != 0) /* Have a remote connection */
5460	{
5461	remote_check_symbols (objfile);
5462	}
5463	/* Call predecessor on chain, if any. */
5464	if (remote_new_objfile_chain != 0 &&
5465	remote_desc == 0)
5466	remote_new_objfile_chain (objfile);
5467	}
5468
5469	void
5470	_initialize_remote (void)
5471	{
5472	static struct cmd_list_element *remote_set_cmdlist;
5473	static struct cmd_list_element *remote_show_cmdlist;
5474	struct cmd_list_element *tmpcmd;
5475
5476	/* architecture specific data */
5477	remote_gdbarch_data_handle = gdbarch_data_register_post_init (init_remote_state);
5478
5479	/* Old tacky stuff. NOTE: This comes after the remote protocol so
5480	that the remote protocol has been initialized. */
5481	DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size)deprecated_register_gdbarch_swap (&(remote_address_size), sizeof ((remote_address_size)), ((void*)0));
5482	deprecated_register_gdbarch_swap (NULL((void*)0), 0, build_remote_gdbarch_data);
5483
5484	init_remote_ops ();
5485	add_target (&remote_ops);
5486
5487	init_extended_remote_ops ();
5488	add_target (&extended_remote_ops);
5489
5490	init_remote_async_ops ();
5491	add_target (&remote_async_ops);
5492
5493	init_extended_async_remote_ops ();
5494	add_target (&extended_async_remote_ops);
5495
5496	/* Hook into new objfile notification. */
5497	remote_new_objfile_chain = deprecated_target_new_objfile_hook;
5498	deprecated_target_new_objfile_hook = remote_new_objfile;
5499
5500	#if 0
5501	init_remote_threadtests ();
5502	#endif
5503
5504	/* set/show remote ... */
5505
5506	add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
5507	Remote protocol specific variables\n\
5508	Configure various remote-protocol specific variables such as\n\
5509	the packets being used",
5510	&remote_set_cmdlist, "set remote ",
5511	0/allow-unknown/, &setlist);
5512	add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, "\
5513	Remote protocol specific variables\n\
5514	Configure various remote-protocol specific variables such as\n\
5515	the packets being used",
5516	&remote_show_cmdlist, "show remote ",
5517	0/allow-unknown/, &showlist);
5518
5519	add_cmd ("compare-sections", class_obscure, compare_sections_command,
5520	"Compare section data on target to the exec file.\n\
5521	Argument is a single section name (default: all loaded sections).",
5522	&cmdlist);
5523
5524	add_cmd ("packet", class_maintenance, packet_command,
5525	"Send an arbitrary packet to a remote target.\n\
5526	maintenance packet TEXT\n\
5527	If GDB is talking to an inferior via the GDB serial protocol, then\n\
5528	this command sends the string TEXT to the inferior, and displays the\n\
5529	response packet. GDB supplies the initial `$' character, and the\n\
5530	terminating `#' character and checksum.",
5531	&maintenancelist);
5532
5533	add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, "\
5534	Set whether to send break if interrupted.", "\
5535	Show whether to send break if interrupted.", "\
5536	If set, a break, instead of a cntrl-c, is sent to the remote target.", "\
5537	Whether to send break if interrupted is %s.",
5538	NULL((void)0), NULL((void)0),
5539	&setlist, &showlist);
5540
5541	/* Install commands for configuring memory read/write packets. */
5542
5543	add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
5544	"Set the maximum number of bytes per memory write packet (deprecated).\n",
5545	&setlist);
5546	add_cmd ("remotewritesize", no_class, show_memory_write_packet_size,
5547	"Show the maximum number of bytes per memory write packet (deprecated).\n",
5548	&showlist);
5549	add_cmd ("memory-write-packet-size", no_class,
5550	set_memory_write_packet_size,
5551	"Set the maximum number of bytes per memory-write packet.\n"
5552	"Specify the number of bytes in a packet or 0 (zero) for the\n"
5553	"default packet size. The actual limit is further reduced\n"
5554	"dependent on the target. Specify ``fixed'' to disable the\n"
5555	"further restriction and ``limit'' to enable that restriction\n",
5556	&remote_set_cmdlist);
5557	add_cmd ("memory-read-packet-size", no_class,
5558	set_memory_read_packet_size,
5559	"Set the maximum number of bytes per memory-read packet.\n"
5560	"Specify the number of bytes in a packet or 0 (zero) for the\n"
5561	"default packet size. The actual limit is further reduced\n"
5562	"dependent on the target. Specify ``fixed'' to disable the\n"
5563	"further restriction and ``limit'' to enable that restriction\n",
5564	&remote_set_cmdlist);
5565	add_cmd ("memory-write-packet-size", no_class,
5566	show_memory_write_packet_size,
5567	"Show the maximum number of bytes per memory-write packet.\n",
5568	&remote_show_cmdlist);
5569	add_cmd ("memory-read-packet-size", no_class,
5570	show_memory_read_packet_size,
5571	"Show the maximum number of bytes per memory-read packet.\n",
5572	&remote_show_cmdlist);
5573
5574	add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
5575	&remote_hw_watchpoint_limit, "\
5576	Set the maximum number of target hardware watchpoints.", "\
5577	Show the maximum number of target hardware watchpoints.", "\
5578	Specify a negative limit for unlimited.", "\
5579	The maximum number of target hardware watchpoints is %s.",
5580	NULL((void)0), NULL((void)0),
5581	&remote_set_cmdlist, &remote_show_cmdlist);
5582	add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
5583	&remote_hw_breakpoint_limit, "\
5584	Set the maximum number of target hardware breakpoints.", "\
5585	Show the maximum number of target hardware breakpoints.", "\
5586	Specify a negative limit for unlimited.", "\
5587	The maximum number of target hardware breakpoints is %s.",
5588	NULL((void)0), NULL((void)0),
5589	&remote_set_cmdlist, &remote_show_cmdlist);
5590
5591	deprecated_add_show_from_set
5592	(add_set_cmd ("remoteaddresssize", class_obscure,
5593	var_integer, (char *) &remote_address_size,
5594	"Set the maximum size of the address (in bits) \
5595	in a memory packet.\n",
5596	&setlist),
5597	&showlist);
5598
5599	add_packet_config_cmd (&remote_protocol_binary_download,
5600	"X", "binary-download",
5601	set_remote_protocol_binary_download_cmd,
5602	show_remote_protocol_binary_download_cmd,
5603	&remote_set_cmdlist, &remote_show_cmdlist,
5604	1);
5605	#if 0
5606	/* XXXX - should ``set remotebinarydownload'' be retained for
5607	compatibility. */
5608	deprecated_add_show_from_set
5609	(add_set_cmd ("remotebinarydownload", no_class,
5610	var_boolean, (char *) &remote_binary_download,
5611	"Set binary downloads.\n", &setlist),
5612	&showlist);
5613	#endif
5614
5615	add_packet_config_cmd (&remote_protocol_vcont,
5616	"vCont", "verbose-resume",
5617	set_remote_protocol_vcont_packet_cmd,
5618	show_remote_protocol_vcont_packet_cmd,
5619	&remote_set_cmdlist, &remote_show_cmdlist,
5620	0);
5621
5622	add_packet_config_cmd (&remote_protocol_qSymbol,
5623	"qSymbol", "symbol-lookup",
5624	set_remote_protocol_qSymbol_packet_cmd,
5625	show_remote_protocol_qSymbol_packet_cmd,
5626	&remote_set_cmdlist, &remote_show_cmdlist,
5627	0);
5628
5629	add_packet_config_cmd (&remote_protocol_P,
5630	"P", "set-register",
5631	set_remote_protocol_P_packet_cmd,
5632	show_remote_protocol_P_packet_cmd,
5633	&remote_set_cmdlist, &remote_show_cmdlist,
5634	1);
5635
5636	add_packet_config_cmd (&remote_protocol_p,
5637	"p", "fetch-register",
5638	set_remote_protocol_p_packet_cmd,
5639	show_remote_protocol_p_packet_cmd,
5640	&remote_set_cmdlist, &remote_show_cmdlist,
5641	1);
5642
5643	add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
5644	"Z0", "software-breakpoint",
5645	set_remote_protocol_Z_software_bp_packet_cmd,
5646	show_remote_protocol_Z_software_bp_packet_cmd,
5647	&remote_set_cmdlist, &remote_show_cmdlist,
5648	0);
5649
5650	add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
5651	"Z1", "hardware-breakpoint",
5652	set_remote_protocol_Z_hardware_bp_packet_cmd,
5653	show_remote_protocol_Z_hardware_bp_packet_cmd,
5654	&remote_set_cmdlist, &remote_show_cmdlist,
5655	0);
5656
5657	add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
5658	"Z2", "write-watchpoint",
5659	set_remote_protocol_Z_write_wp_packet_cmd,
5660	show_remote_protocol_Z_write_wp_packet_cmd,
5661	&remote_set_cmdlist, &remote_show_cmdlist,
5662	0);
5663
5664	add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
5665	"Z3", "read-watchpoint",
5666	set_remote_protocol_Z_read_wp_packet_cmd,
5667	show_remote_protocol_Z_read_wp_packet_cmd,
5668	&remote_set_cmdlist, &remote_show_cmdlist,
5669	0);
5670
5671	add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
5672	"Z4", "access-watchpoint",
5673	set_remote_protocol_Z_access_wp_packet_cmd,
5674	show_remote_protocol_Z_access_wp_packet_cmd,
5675	&remote_set_cmdlist, &remote_show_cmdlist,
5676	0);
5677
5678	add_packet_config_cmd (&remote_protocol_qPart_auxv,
5679	"qPart_auxv", "read-aux-vector",
5680	set_remote_protocol_qPart_auxv_packet_cmd,
5681	show_remote_protocol_qPart_auxv_packet_cmd,
5682	&remote_set_cmdlist, &remote_show_cmdlist,
5683	0);
5684
5685	/* Keep the old ``set remote Z-packet ...'' working. */
5686	add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
5687	&remote_Z_packet_detect, "\
5688	Set use of remote protocol `Z' packets", "\
5689	Show use of remote protocol `Z' packets ", "\
5690	When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
5691	packets.", "\
5692	Use of remote protocol `Z' packets is %s",
5693	set_remote_protocol_Z_packet_cmd,
5694	show_remote_protocol_Z_packet_cmd,
5695	&remote_set_cmdlist, &remote_show_cmdlist);
5696
5697	/* Eventually initialize fileio. See fileio.c */
5698	initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
5699	}