gdb/remote.c

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