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