gdb/remote.c

   1 /* Remote target communications for serial-line targets in custom GDB protocol
   2    Copyright 1988, 1991-2000 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 "gdb_wait.h"
  33 /*#include "terminal.h" */
  34 #include "gdbcmd.h"
  35 #include "objfiles.h"
  36 #include "gdb-stabs.h"
  37 #include "gdbthread.h"
  38 #include "remote.h"
  39
  40 #include <ctype.h>
  41 #include <sys/time.h>
  42 #ifdef USG
  43 #include <sys/types.h>
  44 #endif
  45
  46 #include "event-loop.h"
  47 #include "event-top.h"
  48 #include "inf-loop.h"
  49
  50 #include <signal.h>
  51 #include "serial.h"
  52
  53 /* Prototypes for local functions */
  54 static void cleanup_sigint_signal_handler (void *dummy);
  55 static void initialize_sigint_signal_handler (void);
  56 static int getpkt_sane (char *buf, long sizeof_buf, int forever);
  57
  58 static void handle_remote_sigint (int);
  59 static void handle_remote_sigint_twice (int);
  60 static void async_remote_interrupt (gdb_client_data);
  61 void async_remote_interrupt_twice (gdb_client_data);
  62
  63 static void build_remote_gdbarch_data (void);
  64
  65 static int remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len);
  66
  67 static int remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len);
  68
  69 static void remote_files_info (struct target_ops *ignore);
  70
  71 static int remote_xfer_memory (CORE_ADDR memaddr, char *myaddr,
  72                                int len, int should_write,
  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[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 #ifdef REGISTER_BYTES_OK
3084       if (!REGISTER_BYTES_OK (i))
3085         warning ("Remote reply is too short: %s", buf);
3086 #endif
3087     }
3088
3089 supply_them:
3090   for (i = 0; i < NUM_REGS; i++)
3091     {
3092       supply_register (i, &regs[REGISTER_BYTE (i)]);
3093       if (buf[REGISTER_BYTE (i) * 2] == 'x')
3094         register_valid[i] = -1; /* register value not available */
3095     }
3096 }
3097
3098 /* Prepare to store registers.  Since we may send them all (using a
3099    'G' request), we have to read out the ones we don't want to change
3100    first.  */
3101
3102 static void
3103 remote_prepare_to_store (void)
3104 {
3105   /* Make sure the entire registers array is valid.  */
3106   switch (remote_protocol_P.support)
3107     {
3108     case PACKET_DISABLE:
3109     case PACKET_SUPPORT_UNKNOWN:
3110       read_register_bytes (0, (char *) NULL, REGISTER_BYTES);
3111       break;
3112     case PACKET_ENABLE:
3113       break;
3114     }
3115 }
3116
3117 /* Helper: Attempt to store REGNO using the P packet.  Return fail IFF
3118    packet was not recognized. */
3119
3120 static int
3121 store_register_using_P (int regno)
3122 {
3123   /* Try storing a single register.  */
3124   char *buf = alloca (PBUFSIZ);
3125   char *regp;
3126   char *p;
3127   int i;
3128
3129   sprintf (buf, "P%x=", regno);
3130   p = buf + strlen (buf);
3131   regp = &registers[REGISTER_BYTE (regno)];
3132   for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i)
3133     {
3134       *p++ = tohex ((regp[i] >> 4) & 0xf);
3135       *p++ = tohex (regp[i] & 0xf);
3136     }
3137   *p = '\0';
3138   remote_send (buf, PBUFSIZ);
3139
3140   return buf[0] != '\0';
3141 }
3142
3143
3144 /* Store register REGNO, or all registers if REGNO == -1, from the contents
3145    of REGISTERS.  FIXME: ignores errors.  */
3146
3147 static void
3148 remote_store_registers (int regno)
3149 {
3150   char *buf = alloca (PBUFSIZ);
3151   int i;
3152   char *p;
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   p = buf + 1;
3191   /* remote_prepare_to_store insures that register_bytes_found gets set.  */
3192   for (i = 0; i < register_bytes_found; i++)
3193     {
3194       *p++ = tohex ((registers[i] >> 4) & 0xf);
3195       *p++ = tohex (registers[i] & 0xf);
3196     }
3197   *p = '\0';
3198
3199   remote_send (buf, PBUFSIZ);
3200 }
3201 \f
3202
3203 /* Return the number of hex digits in num.  */
3204
3205 static int
3206 hexnumlen (ULONGEST num)
3207 {
3208   int i;
3209
3210   for (i = 0; num != 0; i++)
3211     num >>= 4;
3212
3213   return max (i, 1);
3214 }
3215
3216 /* Set BUF to the minimum number of hex digits representing NUM.  */
3217
3218 static int
3219 hexnumstr (char *buf, ULONGEST num)
3220 {
3221   int len = hexnumlen (num);
3222   return hexnumnstr (buf, num, len);
3223 }
3224
3225
3226 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters.  */
3227
3228 static int
3229 hexnumnstr (char *buf, ULONGEST num, int width)
3230 {
3231   int i;
3232
3233   buf[width] = '\0';
3234
3235   for (i = width - 1; i >= 0; i--)
3236     {
3237       buf[i] = "0123456789abcdef"[(num & 0xf)];
3238       num >>= 4;
3239     }
3240
3241   return width;
3242 }
3243
3244 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3245
3246 static CORE_ADDR
3247 remote_address_masked (CORE_ADDR addr)
3248 {
3249   if (remote_address_size > 0
3250       && remote_address_size < (sizeof (ULONGEST) * 8))
3251     {
3252       /* Only create a mask when that mask can safely be constructed
3253          in a ULONGEST variable. */
3254       ULONGEST mask = 1;
3255       mask = (mask << remote_address_size) - 1;
3256       addr &= mask;
3257     }
3258   return addr;
3259 }
3260
3261 /* Determine whether the remote target supports binary downloading.
3262    This is accomplished by sending a no-op memory write of zero length
3263    to the target at the specified address. It does not suffice to send
3264    the whole packet, since many stubs strip the eighth bit and subsequently
3265    compute a wrong checksum, which causes real havoc with remote_write_bytes.
3266
3267    NOTE: This can still lose if the serial line is not eight-bit
3268    clean. In cases like this, the user should clear "remote
3269    X-packet". */
3270
3271 static void
3272 check_binary_download (CORE_ADDR addr)
3273 {
3274   switch (remote_protocol_binary_download.support)
3275     {
3276     case PACKET_DISABLE:
3277       break;
3278     case PACKET_ENABLE:
3279       break;
3280     case PACKET_SUPPORT_UNKNOWN:
3281       {
3282         char *buf = alloca (PBUFSIZ);
3283         char *p;
3284
3285         p = buf;
3286         *p++ = 'X';
3287         p += hexnumstr (p, (ULONGEST) addr);
3288         *p++ = ',';
3289         p += hexnumstr (p, (ULONGEST) 0);
3290         *p++ = ':';
3291         *p = '\0';
3292
3293         putpkt_binary (buf, (int) (p - buf));
3294         getpkt (buf, PBUFSIZ, 0);
3295
3296         if (buf[0] == '\0')
3297           {
3298             if (remote_debug)
3299               fprintf_unfiltered (gdb_stdlog,
3300                                   "binary downloading NOT suppported by target\n");
3301             remote_protocol_binary_download.support = PACKET_DISABLE;
3302           }
3303         else
3304           {
3305             if (remote_debug)
3306               fprintf_unfiltered (gdb_stdlog,
3307                                   "binary downloading suppported by target\n");
3308             remote_protocol_binary_download.support = PACKET_ENABLE;
3309           }
3310         break;
3311       }
3312     }
3313 }
3314
3315 /* Write memory data directly to the remote machine.
3316    This does not inform the data cache; the data cache uses this.
3317    MEMADDR is the address in the remote memory space.
3318    MYADDR is the address of the buffer in our space.
3319    LEN is the number of bytes.
3320
3321    Returns number of bytes transferred, or 0 (setting errno) for
3322    error.  Only transfer a single packet. */
3323
3324 static int
3325 remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3326 {
3327   unsigned char *buf;
3328   int max_buf_size;             /* Max size of packet output buffer */
3329   unsigned char *p;
3330   unsigned char *plen;
3331   long sizeof_buf;
3332   int plenlen;
3333   int todo;
3334   int nr_bytes;
3335
3336   /* Verify that the target can support a binary download */
3337   check_binary_download (memaddr);
3338
3339   /* Determine the max packet size. */
3340   max_buf_size = get_memory_write_packet_size ();
3341   sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3342   buf = alloca (sizeof_buf);
3343
3344   /* Subtract header overhead from max payload size -  $M<memaddr>,<len>:#nn */
3345   max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4;
3346
3347   /* construct "M"<memaddr>","<len>":" */
3348   /* sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); */
3349   p = buf;
3350
3351   /* Append [XM].  Compute a best guess of the number of bytes
3352      actually transfered. */
3353   switch (remote_protocol_binary_download.support)
3354     {
3355     case PACKET_ENABLE:
3356       *p++ = 'X';
3357       /* Best guess at number of bytes that will fit. */
3358       todo = min (len, max_buf_size);
3359       break;
3360     case PACKET_DISABLE:
3361       *p++ = 'M';
3362       /* num bytes that will fit */
3363       todo = min (len, max_buf_size / 2);
3364       break;
3365     case PACKET_SUPPORT_UNKNOWN:
3366       internal_error ("%s:%d: remote_write_bytes: bad internal state",
3367                       __FILE__, __LINE__);
3368     default:
3369       internal_error ("%s:%d: bad switch", __FILE__, __LINE__);
3370     }
3371
3372   /* Append <memaddr> */
3373   memaddr = remote_address_masked (memaddr);
3374   p += hexnumstr (p, (ULONGEST) memaddr);
3375   *p++ = ',';
3376
3377   /* Append <len>.  Retain the location/size of <len>.  It may
3378      need to be adjusted once the packet body has been created. */
3379   plen = p;
3380   plenlen = hexnumstr (p, (ULONGEST) todo);
3381   p += plenlen;
3382   *p++ = ':';
3383   *p = '\0';
3384
3385   /* Append the packet body. */
3386   switch (remote_protocol_binary_download.support)
3387     {
3388     case PACKET_ENABLE:
3389       /* Binary mode.  Send target system values byte by byte, in
3390          increasing byte addresses.  Only escape certain critical
3391          characters.  */
3392       for (nr_bytes = 0;
3393            (nr_bytes < todo) && (p - buf) < (max_buf_size - 2);
3394            nr_bytes++)
3395         {
3396           switch (myaddr[nr_bytes] & 0xff)
3397             {
3398             case '$':
3399             case '#':
3400             case 0x7d:
3401               /* These must be escaped */
3402               *p++ = 0x7d;
3403               *p++ = (myaddr[nr_bytes] & 0xff) ^ 0x20;
3404               break;
3405             default:
3406               *p++ = myaddr[nr_bytes] & 0xff;
3407               break;
3408             }
3409         }
3410       if (nr_bytes < todo)
3411         {
3412           /* Escape chars have filled up the buffer prematurely,
3413              and we have actually sent fewer bytes than planned.
3414              Fix-up the length field of the packet.  Use the same
3415              number of characters as before.  */
3416
3417           plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
3418           *plen = ':';  /* overwrite \0 from hexnumnstr() */
3419         }
3420       break;
3421     case PACKET_DISABLE:
3422       /* Normal mode: Send target system values byte by byte, in
3423          increasing byte addresses.  Each byte is encoded as a two hex
3424          value.  */
3425       for (nr_bytes = 0; nr_bytes < todo; nr_bytes++)
3426         {
3427           *p++ = tohex ((myaddr[nr_bytes] >> 4) & 0xf);
3428           *p++ = tohex (myaddr[nr_bytes] & 0xf);
3429         }
3430       *p = '\0';
3431       break;
3432     case PACKET_SUPPORT_UNKNOWN:
3433       internal_error ("%s:%d: remote_write_bytes: bad internal state",
3434                       __FILE__, __LINE__);
3435     default:
3436       internal_error ("%s:%d: bad switch", __FILE__, __LINE__);
3437     }
3438
3439   putpkt_binary (buf, (int) (p - buf));
3440   getpkt (buf, sizeof_buf, 0);
3441
3442   if (buf[0] == 'E')
3443     {
3444       /* There is no correspondance between what the remote protocol
3445          uses for errors and errno codes.  We would like a cleaner way
3446          of representing errors (big enough to include errno codes,
3447          bfd_error codes, and others).  But for now just return EIO.  */
3448       errno = EIO;
3449       return 0;
3450     }
3451
3452   /* Return NR_BYTES, not TODO, in case escape chars caused us to send fewer
3453      bytes than we'd planned.  */
3454   return nr_bytes;
3455 }
3456
3457 /* Read memory data directly from the remote machine.
3458    This does not use the data cache; the data cache uses this.
3459    MEMADDR is the address in the remote memory space.
3460    MYADDR is the address of the buffer in our space.
3461    LEN is the number of bytes.
3462
3463    Returns number of bytes transferred, or 0 for error.  */
3464
3465 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
3466    remote targets) shouldn't attempt to read the entire buffer.
3467    Instead it should read a single packet worth of data and then
3468    return the byte size of that packet to the caller.  The caller (its
3469    caller and its callers caller ;-) already contains code for
3470    handling partial reads. */
3471
3472 static int
3473 remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3474 {
3475   char *buf;
3476   int max_buf_size;             /* Max size of packet output buffer */
3477   long sizeof_buf;
3478   int origlen;
3479
3480   /* Create a buffer big enough for this packet. */
3481   max_buf_size = get_memory_read_packet_size ();
3482   sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3483   buf = alloca (sizeof_buf);
3484
3485   origlen = len;
3486   while (len > 0)
3487     {
3488       char *p;
3489       int todo;
3490       int i;
3491
3492       todo = min (len, max_buf_size / 2);       /* num bytes that will fit */
3493
3494       /* construct "m"<memaddr>","<len>" */
3495       /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3496       memaddr = remote_address_masked (memaddr);
3497       p = buf;
3498       *p++ = 'm';
3499       p += hexnumstr (p, (ULONGEST) memaddr);
3500       *p++ = ',';
3501       p += hexnumstr (p, (ULONGEST) todo);
3502       *p = '\0';
3503
3504       putpkt (buf);
3505       getpkt (buf, sizeof_buf, 0);
3506
3507       if (buf[0] == 'E')
3508         {
3509           /* There is no correspondance between what the remote protocol uses
3510              for errors and errno codes.  We would like a cleaner way of
3511              representing errors (big enough to include errno codes, bfd_error
3512              codes, and others).  But for now just return EIO.  */
3513           errno = EIO;
3514           return 0;
3515         }
3516
3517       /* Reply describes memory byte by byte,
3518          each byte encoded as two hex characters.  */
3519
3520       p = buf;
3521       for (i = 0; i < todo; i++)
3522         {
3523           if (p[0] == 0 || p[1] == 0)
3524             /* Reply is short.  This means that we were able to read
3525                only part of what we wanted to.  */
3526             return i + (origlen - len);
3527           myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3528           p += 2;
3529         }
3530       myaddr += todo;
3531       memaddr += todo;
3532       len -= todo;
3533     }
3534   return origlen;
3535 }
3536 \f
3537 /* Read or write LEN bytes from inferior memory at MEMADDR,
3538    transferring to or from debugger address BUFFER.  Write to inferior if
3539    SHOULD_WRITE is nonzero.  Returns length of data written or read; 0
3540    for error.  TARGET is unused.  */
3541
3542 /* ARGSUSED */
3543 static int
3544 remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
3545                     int should_write, struct target_ops *target)
3546 {
3547   CORE_ADDR targ_addr;
3548   int targ_len;
3549   int res;
3550
3551   REMOTE_TRANSLATE_XFER_ADDRESS (mem_addr, mem_len, &targ_addr, &targ_len);
3552   if (targ_len <= 0)
3553     return 0;
3554
3555   if (should_write)
3556     res = remote_write_bytes (targ_addr, buffer, targ_len);
3557   else
3558     res = remote_read_bytes (targ_addr, buffer, targ_len);
3559
3560   return res;
3561 }
3562
3563
3564 #if 0
3565 /* Enable after 4.12.  */
3566
3567 void
3568 remote_search (int len, char *data, char *mask, CORE_ADDR startaddr,
3569                int increment, CORE_ADDR lorange, CORE_ADDR hirange,
3570                CORE_ADDR *addr_found, char *data_found)
3571 {
3572   if (increment == -4 && len == 4)
3573     {
3574       long mask_long, data_long;
3575       long data_found_long;
3576       CORE_ADDR addr_we_found;
3577       char *buf = alloca (PBUFSIZ);
3578       long returned_long[2];
3579       char *p;
3580
3581       mask_long = extract_unsigned_integer (mask, len);
3582       data_long = extract_unsigned_integer (data, len);
3583       sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long);
3584       putpkt (buf);
3585       getpkt (buf, PBUFSIZ, 0);
3586       if (buf[0] == '\0')
3587         {
3588           /* The stub doesn't support the 't' request.  We might want to
3589              remember this fact, but on the other hand the stub could be
3590              switched on us.  Maybe we should remember it only until
3591              the next "target remote".  */
3592           generic_search (len, data, mask, startaddr, increment, lorange,
3593                           hirange, addr_found, data_found);
3594           return;
3595         }
3596
3597       if (buf[0] == 'E')
3598         /* There is no correspondance between what the remote protocol uses
3599            for errors and errno codes.  We would like a cleaner way of
3600            representing errors (big enough to include errno codes, bfd_error
3601            codes, and others).  But for now just use EIO.  */
3602         memory_error (EIO, startaddr);
3603       p = buf;
3604       addr_we_found = 0;
3605       while (*p != '\0' && *p != ',')
3606         addr_we_found = (addr_we_found << 4) + fromhex (*p++);
3607       if (*p == '\0')
3608         error ("Protocol error: short return for search");
3609
3610       data_found_long = 0;
3611       while (*p != '\0' && *p != ',')
3612         data_found_long = (data_found_long << 4) + fromhex (*p++);
3613       /* Ignore anything after this comma, for future extensions.  */
3614
3615       if (addr_we_found < lorange || addr_we_found >= hirange)
3616         {
3617           *addr_found = 0;
3618           return;
3619         }
3620
3621       *addr_found = addr_we_found;
3622       *data_found = store_unsigned_integer (data_we_found, len);
3623       return;
3624     }
3625   generic_search (len, data, mask, startaddr, increment, lorange,
3626                   hirange, addr_found, data_found);
3627 }
3628 #endif /* 0 */
3629 \f
3630 static void
3631 remote_files_info (struct target_ops *ignore)
3632 {
3633   puts_filtered ("Debugging a target over a serial line.\n");
3634 }
3635 \f
3636 /* Stuff for dealing with the packets which are part of this protocol.
3637    See comment at top of file for details.  */
3638
3639 /* Read a single character from the remote end, masking it down to 7 bits. */
3640
3641 static int
3642 readchar (int timeout)
3643 {
3644   int ch;
3645
3646   ch = SERIAL_READCHAR (remote_desc, timeout);
3647
3648   if (ch >= 0)
3649     return (ch & 0x7f);
3650
3651   switch ((enum serial_rc) ch)
3652     {
3653     case SERIAL_EOF:
3654       target_mourn_inferior ();
3655       error ("Remote connection closed");
3656       /* no return */
3657     case SERIAL_ERROR:
3658       perror_with_name ("Remote communication error");
3659       /* no return */
3660     case SERIAL_TIMEOUT:
3661       break;
3662     }
3663   return ch;
3664 }
3665
3666 /* Send the command in BUF to the remote machine, and read the reply
3667    into BUF.  Report an error if we get an error reply.  */
3668
3669 static void
3670 remote_send (char *buf,
3671              long sizeof_buf)
3672 {
3673   putpkt (buf);
3674   getpkt (buf, sizeof_buf, 0);
3675
3676   if (buf[0] == 'E')
3677     error ("Remote failure reply: %s", buf);
3678 }
3679
3680 /* Display a null-terminated packet on stdout, for debugging, using C
3681    string notation.  */
3682
3683 static void
3684 print_packet (char *buf)
3685 {
3686   puts_filtered ("\"");
3687   fputstr_filtered (buf, '"', gdb_stdout);
3688   puts_filtered ("\"");
3689 }
3690
3691 int
3692 putpkt (char *buf)
3693 {
3694   return putpkt_binary (buf, strlen (buf));
3695 }
3696
3697 /* Send a packet to the remote machine, with error checking.  The data
3698    of the packet is in BUF.  The string in BUF can be at most  PBUFSIZ - 5
3699    to account for the $, # and checksum, and for a possible /0 if we are
3700    debugging (remote_debug) and want to print the sent packet as a string */
3701
3702 static int
3703 putpkt_binary (char *buf, int cnt)
3704 {
3705   int i;
3706   unsigned char csum = 0;
3707   char *buf2 = alloca (cnt + 6);
3708   long sizeof_junkbuf = PBUFSIZ;
3709   char *junkbuf = alloca (sizeof_junkbuf);
3710
3711   int ch;
3712   int tcount = 0;
3713   char *p;
3714
3715   /* Copy the packet into buffer BUF2, encapsulating it
3716      and giving it a checksum.  */
3717
3718   p = buf2;
3719   *p++ = '$';
3720
3721   for (i = 0; i < cnt; i++)
3722     {
3723       csum += buf[i];
3724       *p++ = buf[i];
3725     }
3726   *p++ = '#';
3727   *p++ = tohex ((csum >> 4) & 0xf);
3728   *p++ = tohex (csum & 0xf);
3729
3730   /* Send it over and over until we get a positive ack.  */
3731
3732   while (1)
3733     {
3734       int started_error_output = 0;
3735
3736       if (remote_debug)
3737         {
3738           *p = '\0';
3739           fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
3740           fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
3741           fprintf_unfiltered (gdb_stdlog, "...");
3742           gdb_flush (gdb_stdlog);
3743         }
3744       if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
3745         perror_with_name ("putpkt: write failed");
3746
3747       /* read until either a timeout occurs (-2) or '+' is read */
3748       while (1)
3749         {
3750           ch = readchar (remote_timeout);
3751
3752           if (remote_debug)
3753             {
3754               switch (ch)
3755                 {
3756                 case '+':
3757                 case '-':
3758                 case SERIAL_TIMEOUT:
3759                 case '$':
3760                   if (started_error_output)
3761                     {
3762                       putchar_unfiltered ('\n');
3763                       started_error_output = 0;
3764                     }
3765                 }
3766             }
3767
3768           switch (ch)
3769             {
3770             case '+':
3771               if (remote_debug)
3772                 fprintf_unfiltered (gdb_stdlog, "Ack\n");
3773               return 1;
3774             case '-':
3775               if (remote_debug)
3776                 fprintf_unfiltered (gdb_stdlog, "Nak\n");
3777             case SERIAL_TIMEOUT:
3778               tcount++;
3779               if (tcount > 3)
3780                 return 0;
3781               break;            /* Retransmit buffer */
3782             case '$':
3783               {
3784                 if (remote_debug)
3785                   fprintf_unfiltered (gdb_stdlog, "Packet instead of Ack, ignoring it\n");
3786                 /* It's probably an old response, and we're out of sync.
3787                    Just gobble up the packet and ignore it.  */
3788                 read_frame (junkbuf, sizeof_junkbuf);
3789                 continue;       /* Now, go look for + */
3790               }
3791             default:
3792               if (remote_debug)
3793                 {
3794                   if (!started_error_output)
3795                     {
3796                       started_error_output = 1;
3797                       fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
3798                     }
3799                   fputc_unfiltered (ch & 0177, gdb_stdlog);
3800                 }
3801               continue;
3802             }
3803           break;                /* Here to retransmit */
3804         }
3805
3806 #if 0
3807       /* This is wrong.  If doing a long backtrace, the user should be
3808          able to get out next time we call QUIT, without anything as
3809          violent as interrupt_query.  If we want to provide a way out of
3810          here without getting to the next QUIT, it should be based on
3811          hitting ^C twice as in remote_wait.  */
3812       if (quit_flag)
3813         {
3814           quit_flag = 0;
3815           interrupt_query ();
3816         }
3817 #endif
3818     }
3819 }
3820
3821 static int remote_cisco_mode;
3822
3823 /* Come here after finding the start of the frame.  Collect the rest
3824    into BUF, verifying the checksum, length, and handling run-length
3825    compression.  No more than sizeof_buf-1 characters are read so that
3826    the buffer can be NUL terminated.
3827
3828    Returns -1 on error, number of characters in buffer (ignoring the
3829    trailing NULL) on success. (could be extended to return one of the
3830    SERIAL status indications). */
3831
3832 static long
3833 read_frame (char *buf,
3834             long sizeof_buf)
3835 {
3836   unsigned char csum;
3837   long bc;
3838   int c;
3839
3840   csum = 0;
3841   bc = 0;
3842
3843   while (1)
3844     {
3845       /* ASSERT (bc < sizeof_buf - 1) - space for trailing NUL */
3846       c = readchar (remote_timeout);
3847       switch (c)
3848         {
3849         case SERIAL_TIMEOUT:
3850           if (remote_debug)
3851             fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
3852           return -1;
3853         case '$':
3854           if (remote_debug)
3855             fputs_filtered ("Saw new packet start in middle of old one\n",
3856                             gdb_stdlog);
3857           return -1;            /* Start a new packet, count retries */
3858         case '#':
3859           {
3860             unsigned char pktcsum;
3861             int check_0 = 0;
3862             int check_1 = 0;
3863
3864             buf[bc] = '\0';
3865
3866             check_0 = readchar (remote_timeout);
3867             if (check_0 >= 0)
3868               check_1 = readchar (remote_timeout);
3869
3870             if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
3871               {
3872                 if (remote_debug)
3873                   fputs_filtered ("Timeout in checksum, retrying\n", gdb_stdlog);
3874                 return -1;
3875               }
3876             else if (check_0 < 0 || check_1 < 0)
3877               {
3878                 if (remote_debug)
3879                   fputs_filtered ("Communication error in checksum\n", gdb_stdlog);
3880                 return -1;
3881               }
3882
3883             pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
3884             if (csum == pktcsum)
3885               return bc;
3886
3887             if (remote_debug)
3888               {
3889                 fprintf_filtered (gdb_stdlog,
3890                               "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
3891                                   pktcsum, csum);
3892                 fputs_filtered (buf, gdb_stdlog);
3893                 fputs_filtered ("\n", gdb_stdlog);
3894               }
3895             /* Number of characters in buffer ignoring trailing
3896                NUL. */
3897             return -1;
3898           }
3899         case '*':               /* Run length encoding */
3900           {
3901             int repeat;
3902             csum += c;
3903
3904             if (remote_cisco_mode == 0)
3905               {
3906                 c = readchar (remote_timeout);
3907                 csum += c;
3908                 repeat = c - ' ' + 3;   /* Compute repeat count */
3909               }
3910             else
3911               {
3912                 /* Cisco's run-length encoding variant uses two
3913                    hex chars to represent the repeat count. */
3914
3915                 c = readchar (remote_timeout);
3916                 csum += c;
3917                 repeat  = fromhex (c) << 4;
3918                 c = readchar (remote_timeout);
3919                 csum += c;
3920                 repeat += fromhex (c);
3921               }
3922
3923             /* The character before ``*'' is repeated. */
3924
3925             if (repeat > 0 && repeat <= 255
3926                 && bc > 0
3927                 && bc + repeat < sizeof_buf - 1)
3928               {
3929                 memset (&buf[bc], buf[bc - 1], repeat);
3930                 bc += repeat;
3931                 continue;
3932               }
3933
3934             buf[bc] = '\0';
3935             printf_filtered ("Repeat count %d too large for buffer: ", repeat);
3936             puts_filtered (buf);
3937             puts_filtered ("\n");
3938             return -1;
3939           }
3940         default:
3941           if (bc < sizeof_buf - 1)
3942             {
3943               buf[bc++] = c;
3944               csum += c;
3945               continue;
3946             }
3947
3948           buf[bc] = '\0';
3949           puts_filtered ("Remote packet too long: ");
3950           puts_filtered (buf);
3951           puts_filtered ("\n");
3952
3953           return -1;
3954         }
3955     }
3956 }
3957
3958 /* Read a packet from the remote machine, with error checking, and
3959    store it in BUF.  If FOREVER, wait forever rather than timing out;
3960    this is used (in synchronous mode) to wait for a target that is is
3961    executing user code to stop.  */
3962 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
3963    don't have to change all the calls to getpkt to deal with the
3964    return value, because at the moment I don't know what the right
3965    thing to do it for those. */
3966 void
3967 getpkt (char *buf,
3968         long sizeof_buf,
3969         int forever)
3970 {
3971   int timed_out;
3972
3973   timed_out = getpkt_sane (buf, sizeof_buf, forever);
3974 }
3975
3976
3977 /* Read a packet from the remote machine, with error checking, and
3978    store it in BUF.  If FOREVER, wait forever rather than timing out;
3979    this is used (in synchronous mode) to wait for a target that is is
3980    executing user code to stop. If FOREVER == 0, this function is
3981    allowed to time out gracefully and return an indication of this to
3982    the caller. */
3983 int
3984 getpkt_sane (char *buf,
3985         long sizeof_buf,
3986         int forever)
3987 {
3988   int c;
3989   int tries;
3990   int timeout;
3991   int val;
3992
3993   strcpy (buf, "timeout");
3994
3995   if (forever)
3996     {
3997       timeout = watchdog > 0 ? watchdog : -1;
3998     }
3999
4000   else
4001     timeout = remote_timeout;
4002
4003 #define MAX_TRIES 3
4004
4005   for (tries = 1; tries <= MAX_TRIES; tries++)
4006     {
4007       /* This can loop forever if the remote side sends us characters
4008          continuously, but if it pauses, we'll get a zero from readchar
4009          because of timeout.  Then we'll count that as a retry.  */
4010
4011       /* Note that we will only wait forever prior to the start of a packet.
4012          After that, we expect characters to arrive at a brisk pace.  They
4013          should show up within remote_timeout intervals.  */
4014
4015       do
4016         {
4017           c = readchar (timeout);
4018
4019           if (c == SERIAL_TIMEOUT)
4020             {
4021               if (forever)      /* Watchdog went off?  Kill the target. */
4022                 {
4023                   QUIT;
4024                   target_mourn_inferior ();
4025                   error ("Watchdog has expired.  Target detached.\n");
4026                 }
4027               if (remote_debug)
4028                 fputs_filtered ("Timed out.\n", gdb_stdlog);
4029               goto retry;
4030             }
4031         }
4032       while (c != '$');
4033
4034       /* We've found the start of a packet, now collect the data.  */
4035
4036       val = read_frame (buf, sizeof_buf);
4037
4038       if (val >= 0)
4039         {
4040           if (remote_debug)
4041             {
4042               fprintf_unfiltered (gdb_stdlog, "Packet received: ");
4043               fputstr_unfiltered (buf, 0, gdb_stdlog);
4044               fprintf_unfiltered (gdb_stdlog, "\n");
4045             }
4046           SERIAL_WRITE (remote_desc, "+", 1);
4047           return 0;
4048         }
4049
4050       /* Try the whole thing again.  */
4051     retry:
4052       SERIAL_WRITE (remote_desc, "-", 1);
4053     }
4054
4055   /* We have tried hard enough, and just can't receive the packet.  Give up. */
4056
4057   printf_unfiltered ("Ignoring packet error, continuing...\n");
4058   SERIAL_WRITE (remote_desc, "+", 1);
4059   return 1;
4060 }
4061 \f
4062 static void
4063 remote_kill (void)
4064 {
4065   /* For some mysterious reason, wait_for_inferior calls kill instead of
4066      mourn after it gets TARGET_WAITKIND_SIGNALLED.  Work around it.  */
4067   if (kill_kludge)
4068     {
4069       kill_kludge = 0;
4070       target_mourn_inferior ();
4071       return;
4072     }
4073
4074   /* Use catch_errors so the user can quit from gdb even when we aren't on
4075      speaking terms with the remote system.  */
4076   catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4077
4078   /* Don't wait for it to die.  I'm not really sure it matters whether
4079      we do or not.  For the existing stubs, kill is a noop.  */
4080   target_mourn_inferior ();
4081 }
4082
4083 /* Async version of remote_kill. */
4084 static void
4085 remote_async_kill (void)
4086 {
4087   /* Unregister the file descriptor from the event loop. */
4088   if (target_is_async_p ())
4089     SERIAL_ASYNC (remote_desc, NULL, 0);
4090
4091   /* For some mysterious reason, wait_for_inferior calls kill instead of
4092      mourn after it gets TARGET_WAITKIND_SIGNALLED.  Work around it.  */
4093   if (kill_kludge)
4094     {
4095       kill_kludge = 0;
4096       target_mourn_inferior ();
4097       return;
4098     }
4099
4100   /* Use catch_errors so the user can quit from gdb even when we aren't on
4101      speaking terms with the remote system.  */
4102   catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4103
4104   /* Don't wait for it to die.  I'm not really sure it matters whether
4105      we do or not.  For the existing stubs, kill is a noop.  */
4106   target_mourn_inferior ();
4107 }
4108
4109 static void
4110 remote_mourn (void)
4111 {
4112   remote_mourn_1 (&remote_ops);
4113 }
4114
4115 static void
4116 remote_async_mourn (void)
4117 {
4118   remote_mourn_1 (&remote_async_ops);
4119 }
4120
4121 static void
4122 extended_remote_mourn (void)
4123 {
4124   /* We do _not_ want to mourn the target like this; this will
4125      remove the extended remote target  from the target stack,
4126      and the next time the user says "run" it'll fail.
4127
4128      FIXME: What is the right thing to do here?  */
4129 #if 0
4130   remote_mourn_1 (&extended_remote_ops);
4131 #endif
4132 }
4133
4134 /* Worker function for remote_mourn.  */
4135 static void
4136 remote_mourn_1 (struct target_ops *target)
4137 {
4138   unpush_target (target);
4139   generic_mourn_inferior ();
4140 }
4141
4142 /* In the extended protocol we want to be able to do things like
4143    "run" and have them basically work as expected.  So we need
4144    a special create_inferior function.
4145
4146    FIXME: One day add support for changing the exec file
4147    we're debugging, arguments and an environment.  */
4148
4149 static void
4150 extended_remote_create_inferior (char *exec_file, char *args, char **env)
4151 {
4152   /* Rip out the breakpoints; we'll reinsert them after restarting
4153      the remote server.  */
4154   remove_breakpoints ();
4155
4156   /* Now restart the remote server.  */
4157   extended_remote_restart ();
4158
4159   /* Now put the breakpoints back in.  This way we're safe if the
4160      restart function works via a unix fork on the remote side.  */
4161   insert_breakpoints ();
4162
4163   /* Clean up from the last time we were running.  */
4164   clear_proceed_status ();
4165
4166   /* Let the remote process run.  */
4167   proceed (-1, TARGET_SIGNAL_0, 0);
4168 }
4169
4170 /* Async version of extended_remote_create_inferior. */
4171 static void
4172 extended_remote_async_create_inferior (char *exec_file, char *args, char **env)
4173 {
4174   /* Rip out the breakpoints; we'll reinsert them after restarting
4175      the remote server.  */
4176   remove_breakpoints ();
4177
4178   /* If running asynchronously, register the target file descriptor
4179      with the event loop. */
4180   if (event_loop_p && target_can_async_p ())
4181     target_async (inferior_event_handler, 0);
4182
4183   /* Now restart the remote server.  */
4184   extended_remote_restart ();
4185
4186   /* Now put the breakpoints back in.  This way we're safe if the
4187      restart function works via a unix fork on the remote side.  */
4188   insert_breakpoints ();
4189
4190   /* Clean up from the last time we were running.  */
4191   clear_proceed_status ();
4192
4193   /* Let the remote process run.  */
4194   proceed (-1, TARGET_SIGNAL_0, 0);
4195 }
4196 \f
4197
4198 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
4199    than other targets; in those use REMOTE_BREAKPOINT instead of just
4200    BREAKPOINT.  Also, bi-endian targets may define LITTLE_REMOTE_BREAKPOINT
4201    and BIG_REMOTE_BREAKPOINT.  If none of these are defined, we just call
4202    the standard routines that are in mem-break.c.  */
4203
4204 /* FIXME, these ought to be done in a more dynamic fashion.  For instance,
4205    the choice of breakpoint instruction affects target program design and
4206    vice versa, and by making it user-tweakable, the special code here
4207    goes away and we need fewer special GDB configurations.  */
4208
4209 #if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT)
4210 #define REMOTE_BREAKPOINT
4211 #endif
4212
4213 #ifdef REMOTE_BREAKPOINT
4214
4215 /* If the target isn't bi-endian, just pretend it is.  */
4216 #if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT)
4217 #define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
4218 #define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
4219 #endif
4220
4221 static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT;
4222 static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT;
4223
4224 #endif /* REMOTE_BREAKPOINT */
4225
4226 /* Insert a breakpoint on targets that don't have any better breakpoint
4227    support.  We read the contents of the target location and stash it,
4228    then overwrite it with a breakpoint instruction.  ADDR is the target
4229    location in the target machine.  CONTENTS_CACHE is a pointer to
4230    memory allocated for saving the target contents.  It is guaranteed
4231    by the caller to be long enough to save sizeof BREAKPOINT bytes (this
4232    is accomplished via BREAKPOINT_MAX).  */
4233
4234 static int
4235 remote_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
4236 {
4237 #ifdef REMOTE_BREAKPOINT
4238   int val;
4239 #endif
4240   int bp_size;
4241
4242   /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4243      If it succeeds, then set the support to PACKET_ENABLE.  If it
4244      fails, and the user has explicitly requested the Z support then
4245      report an error, otherwise, mark it disabled and go on. */
4246
4247   if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4248     {
4249       char *buf = alloca (PBUFSIZ);
4250       char *p = buf;
4251
4252       addr = remote_address_masked (addr);
4253       *(p++) = 'Z';
4254       *(p++) = '0';
4255       *(p++) = ',';
4256       p += hexnumstr (p, (ULONGEST) addr);
4257       BREAKPOINT_FROM_PC (&addr, &bp_size);
4258       sprintf (p, ",%d", bp_size);
4259
4260       putpkt (buf);
4261       getpkt (buf, PBUFSIZ, 0);
4262
4263       switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_SOFTWARE_BP]))
4264         {
4265         case PACKET_ERROR:
4266           return -1;
4267         case PACKET_OK:
4268           return 0;
4269         case PACKET_UNKNOWN:
4270           break;
4271         }
4272     }
4273
4274 #ifdef REMOTE_BREAKPOINT
4275   val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
4276
4277   if (val == 0)
4278     {
4279       if (TARGET_BYTE_ORDER == BIG_ENDIAN)
4280         val = target_write_memory (addr, (char *) big_break_insn,
4281                                    sizeof big_break_insn);
4282       else
4283         val = target_write_memory (addr, (char *) little_break_insn,
4284                                    sizeof little_break_insn);
4285     }
4286
4287   return val;
4288 #else
4289   return memory_insert_breakpoint (addr, contents_cache);
4290 #endif /* REMOTE_BREAKPOINT */
4291 }
4292
4293 static int
4294 remote_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
4295 {
4296   int bp_size;
4297
4298   if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4299     {
4300       char *buf = alloca (PBUFSIZ);
4301       char *p = buf;
4302
4303       *(p++) = 'z';
4304       *(p++) = '0';
4305       *(p++) = ',';
4306
4307       addr = remote_address_masked (addr);
4308       p += hexnumstr (p, (ULONGEST) addr);
4309       BREAKPOINT_FROM_PC (&addr, &bp_size);
4310       sprintf (p, ",%d", bp_size);
4311
4312       putpkt (buf);
4313       getpkt (buf, PBUFSIZ, 0);
4314
4315       return (buf[0] == 'E');
4316     }
4317
4318 #ifdef REMOTE_BREAKPOINT
4319   return target_write_memory (addr, contents_cache, sizeof big_break_insn);
4320 #else
4321   return memory_remove_breakpoint (addr, contents_cache);
4322 #endif /* REMOTE_BREAKPOINT */
4323 }
4324
4325 static int
4326 watchpoint_to_Z_packet (int type)
4327 {
4328   switch (type)
4329     {
4330     case hw_write:
4331       return 2;
4332       break;
4333     case hw_read:
4334       return 3;
4335       break;
4336     case hw_access:
4337       return 4;
4338       break;
4339     default:
4340       internal_error ("hw_bp_to_z: bad watchpoint type %d", type);
4341     }
4342 }
4343
4344 /* FIXME: This function should be static and a member of the remote
4345    target vector. */
4346
4347 int
4348 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
4349 {
4350   char *buf = alloca (PBUFSIZ);
4351   char *p;
4352   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4353
4354   if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4355     error ("Can't set hardware watchpoints without the '%s' (%s) packet\n",
4356            remote_protocol_Z[packet].name,
4357            remote_protocol_Z[packet].title);
4358
4359   sprintf (buf, "Z%x,", packet);
4360   p = strchr (buf, '\0');
4361   addr = remote_address_masked (addr);
4362   p += hexnumstr (p, (ULONGEST) addr);
4363   sprintf (p, ",%x", len);
4364
4365   putpkt (buf);
4366   getpkt (buf, PBUFSIZ, 0);
4367
4368   switch (packet_ok (buf, &remote_protocol_Z[packet]))
4369     {
4370     case PACKET_ERROR:
4371     case PACKET_UNKNOWN:
4372       return -1;
4373     case PACKET_OK:
4374       return 0;
4375     }
4376   internal_error ("remote_insert_watchpoint: reached end of function");
4377 }
4378
4379 /* FIXME: This function should be static and a member of the remote
4380    target vector. */
4381
4382 int
4383 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
4384 {
4385   char *buf = alloca (PBUFSIZ);
4386   char *p;
4387   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4388
4389   if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4390     error ("Can't clear hardware watchpoints without the '%s' (%s) packet\n",
4391            remote_protocol_Z[packet].name,
4392            remote_protocol_Z[packet].title);
4393
4394   sprintf (buf, "z%x,", packet);
4395   p = strchr (buf, '\0');
4396   addr = remote_address_masked (addr);
4397   p += hexnumstr (p, (ULONGEST) addr);
4398   sprintf (p, ",%x", len);
4399   putpkt (buf);
4400   getpkt (buf, PBUFSIZ, 0);
4401
4402   switch (packet_ok (buf, &remote_protocol_Z[packet]))
4403     {
4404     case PACKET_ERROR:
4405     case PACKET_UNKNOWN:
4406       return -1;
4407     case PACKET_OK:
4408       return 0;
4409     }
4410   internal_error ("remote_remove_watchpoint: reached end of function");
4411 }
4412
4413 /* FIXME: This function should be static and a member of the remote
4414    target vector. */
4415
4416 int
4417 remote_insert_hw_breakpoint (CORE_ADDR addr, int len)
4418 {
4419   char *buf = alloca (PBUFSIZ);
4420   char *p = buf;
4421
4422   if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4423     error ("Can't set hardware breakpoint without the '%s' (%s) packet\n",
4424            remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4425            remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4426
4427   *(p++) = 'Z';
4428   *(p++) = '1';
4429   *(p++) = ',';
4430
4431   addr = remote_address_masked (addr);
4432   p += hexnumstr (p, (ULONGEST) addr);
4433   *p = '\0';
4434
4435   putpkt (buf);
4436   getpkt (buf, PBUFSIZ, 0);
4437
4438   switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4439     {
4440     case PACKET_ERROR:
4441     case PACKET_UNKNOWN:
4442       return -1;
4443     case PACKET_OK:
4444       return 0;
4445     }
4446   internal_error ("remote_remove_watchpoint: reached end of function");
4447 }
4448
4449 /* FIXME: This function should be static and a member of the remote
4450    target vector. */
4451
4452 int
4453 remote_remove_hw_breakpoint (CORE_ADDR addr, int len)
4454 {
4455   char *buf = alloca (PBUFSIZ);
4456   char *p = buf;
4457
4458   if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4459     error ("Can't clear hardware breakpoint without the '%s' (%s) packet\n",
4460            remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4461            remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4462
4463   *(p++) = 'z';
4464   *(p++) = '1';
4465   *(p++) = ',';
4466
4467   addr = remote_address_masked (addr);
4468   p += hexnumstr (p, (ULONGEST) addr);
4469   *p = '\0';
4470
4471   putpkt(buf);
4472   getpkt (buf, PBUFSIZ, 0);
4473
4474   switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4475     {
4476     case PACKET_ERROR:
4477     case PACKET_UNKNOWN:
4478       return -1;
4479     case PACKET_OK:
4480       return 0;
4481     }
4482   internal_error ("remote_remove_watchpoint: reached end of function");
4483 }
4484
4485 /* Some targets are only capable of doing downloads, and afterwards
4486    they switch to the remote serial protocol.  This function provides
4487    a clean way to get from the download target to the remote target.
4488    It's basically just a wrapper so that we don't have to expose any
4489    of the internal workings of remote.c.
4490
4491    Prior to calling this routine, you should shutdown the current
4492    target code, else you will get the "A program is being debugged
4493    already..." message.  Usually a call to pop_target() suffices.  */
4494
4495 void
4496 push_remote_target (char *name, int from_tty)
4497 {
4498   printf_filtered ("Switching to remote protocol\n");
4499   remote_open (name, from_tty);
4500 }
4501
4502 /* Other targets want to use the entire remote serial module but with
4503    certain remote_ops overridden. */
4504
4505 void
4506 open_remote_target (char *name, int from_tty, struct target_ops *target,
4507                     int extended_p)
4508 {
4509   printf_filtered ("Selecting the %sremote protocol\n",
4510                    (extended_p ? "extended-" : ""));
4511   remote_open_1 (name, from_tty, target, extended_p);
4512 }
4513
4514 /* Table used by the crc32 function to calcuate the checksum. */
4515
4516 static unsigned long crc32_table[256] =
4517 {0, 0};
4518
4519 static unsigned long
4520 crc32 (unsigned char *buf, int len, unsigned int crc)
4521 {
4522   if (!crc32_table[1])
4523     {
4524       /* Initialize the CRC table and the decoding table. */
4525       int i, j;
4526       unsigned int c;
4527
4528       for (i = 0; i < 256; i++)
4529         {
4530           for (c = i << 24, j = 8; j > 0; --j)
4531             c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
4532           crc32_table[i] = c;
4533         }
4534     }
4535
4536   while (len--)
4537     {
4538       crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
4539       buf++;
4540     }
4541   return crc;
4542 }
4543
4544 /* compare-sections command
4545
4546    With no arguments, compares each loadable section in the exec bfd
4547    with the same memory range on the target, and reports mismatches.
4548    Useful for verifying the image on the target against the exec file.
4549    Depends on the target understanding the new "qCRC:" request.  */
4550
4551 /* FIXME: cagney/1999-10-26: This command should be broken down into a
4552    target method (target verify memory) and generic version of the
4553    actual command.  This will allow other high-level code (especially
4554    generic_load()) to make use of this target functionality. */
4555
4556 static void
4557 compare_sections_command (char *args, int from_tty)
4558 {
4559   asection *s;
4560   unsigned long host_crc, target_crc;
4561   extern bfd *exec_bfd;
4562   struct cleanup *old_chain;
4563   char *tmp;
4564   char *sectdata;
4565   char *sectname;
4566   char *buf = alloca (PBUFSIZ);
4567   bfd_size_type size;
4568   bfd_vma lma;
4569   int matched = 0;
4570   int mismatched = 0;
4571
4572   if (!exec_bfd)
4573     error ("command cannot be used without an exec file");
4574   if (!current_target.to_shortname ||
4575       strcmp (current_target.to_shortname, "remote") != 0)
4576     error ("command can only be used with remote target");
4577
4578   for (s = exec_bfd->sections; s; s = s->next)
4579     {
4580       if (!(s->flags & SEC_LOAD))
4581         continue;               /* skip non-loadable section */
4582
4583       size = bfd_get_section_size_before_reloc (s);
4584       if (size == 0)
4585         continue;               /* skip zero-length section */
4586
4587       sectname = (char *) bfd_get_section_name (exec_bfd, s);
4588       if (args && strcmp (args, sectname) != 0)
4589         continue;               /* not the section selected by user */
4590
4591       matched = 1;              /* do this section */
4592       lma = s->lma;
4593       /* FIXME: assumes lma can fit into long */
4594       sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
4595       putpkt (buf);
4596
4597       /* be clever; compute the host_crc before waiting for target reply */
4598       sectdata = xmalloc (size);
4599       old_chain = make_cleanup (free, sectdata);
4600       bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
4601       host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
4602
4603       getpkt (buf, PBUFSIZ, 0);
4604       if (buf[0] == 'E')
4605         error ("target memory fault, section %s, range 0x%08x -- 0x%08x",
4606                sectname, lma, lma + size);
4607       if (buf[0] != 'C')
4608         error ("remote target does not support this operation");
4609
4610       for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
4611         target_crc = target_crc * 16 + fromhex (*tmp);
4612
4613       printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
4614                        sectname, paddr (lma), paddr (lma + size));
4615       if (host_crc == target_crc)
4616         printf_filtered ("matched.\n");
4617       else
4618         {
4619           printf_filtered ("MIS-MATCHED!\n");
4620           mismatched++;
4621         }
4622
4623       do_cleanups (old_chain);
4624     }
4625   if (mismatched > 0)
4626     warning ("One or more sections of the remote executable does not match\n\
4627 the loaded file\n");
4628   if (args && !matched)
4629     printf_filtered ("No loaded section named '%s'.\n", args);
4630 }
4631
4632 static int
4633 remote_query (int query_type, char *buf, char *outbuf, int *bufsiz)
4634 {
4635   int i;
4636   char *buf2 = alloca (PBUFSIZ);
4637   char *p2 = &buf2[0];
4638
4639   if (!bufsiz)
4640     error ("null pointer to remote bufer size specified");
4641
4642   /* minimum outbuf size is PBUFSIZ - if bufsiz is not large enough let
4643      the caller know and return what the minimum size is   */
4644   /* Note: a zero bufsiz can be used to query the minimum buffer size */
4645   if (*bufsiz < PBUFSIZ)
4646     {
4647       *bufsiz = PBUFSIZ;
4648       return -1;
4649     }
4650
4651   /* except for querying the minimum buffer size, target must be open */
4652   if (!remote_desc)
4653     error ("remote query is only available after target open");
4654
4655   /* we only take uppercase letters as query types, at least for now */
4656   if ((query_type < 'A') || (query_type > 'Z'))
4657     error ("invalid remote query type");
4658
4659   if (!buf)
4660     error ("null remote query specified");
4661
4662   if (!outbuf)
4663     error ("remote query requires a buffer to receive data");
4664
4665   outbuf[0] = '\0';
4666
4667   *p2++ = 'q';
4668   *p2++ = query_type;
4669
4670   /* we used one buffer char for the remote protocol q command and another
4671      for the query type.  As the remote protocol encapsulation uses 4 chars
4672      plus one extra in case we are debugging (remote_debug),
4673      we have PBUFZIZ - 7 left to pack the query string */
4674   i = 0;
4675   while (buf[i] && (i < (PBUFSIZ - 8)))
4676     {
4677       /* bad caller may have sent forbidden characters */
4678       if ((!isprint (buf[i])) || (buf[i] == '$') || (buf[i] == '#'))
4679         error ("illegal characters in query string");
4680
4681       *p2++ = buf[i];
4682       i++;
4683     }
4684   *p2 = buf[i];
4685
4686   if (buf[i])
4687     error ("query larger than available buffer");
4688
4689   i = putpkt (buf2);
4690   if (i < 0)
4691     return i;
4692
4693   getpkt (outbuf, *bufsiz, 0);
4694
4695   return 0;
4696 }
4697
4698 static void
4699 remote_rcmd (char *command,
4700              struct ui_file *outbuf)
4701 {
4702   int i;
4703   char *buf = alloca (PBUFSIZ);
4704   char *p = buf;
4705
4706   if (!remote_desc)
4707     error ("remote rcmd is only available after target open");
4708
4709   /* Send a NULL command across as an empty command */
4710   if (command == NULL)
4711     command = "";
4712
4713   /* The query prefix */
4714   strcpy (buf, "qRcmd,");
4715   p = strchr (buf, '\0');
4716
4717   if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > PBUFSIZ)
4718     error ("\"monitor\" command ``%s'' is too long\n", command);
4719
4720   /* Encode the actual command */
4721   for (i = 0; command[i]; i++)
4722     {
4723       *p++ = tohex ((command[i] >> 4) & 0xf);
4724       *p++ = tohex (command[i] & 0xf);
4725     }
4726   *p = '\0';
4727
4728   if (putpkt (buf) < 0)
4729     error ("Communication problem with target\n");
4730
4731   /* get/display the response */
4732   while (1)
4733     {
4734       /* XXX - see also tracepoint.c:remote_get_noisy_reply() */
4735       buf[0] = '\0';
4736       getpkt (buf, PBUFSIZ, 0);
4737       if (buf[0] == '\0')
4738         error ("Target does not support this command\n");
4739       if (buf[0] == 'O' && buf[1] != 'K')
4740         {
4741           remote_console_output (buf + 1); /* 'O' message from stub */
4742           continue;
4743         }
4744       if (strcmp (buf, "OK") == 0)
4745         break;
4746       if (strlen (buf) == 3 && buf[0] == 'E'
4747           && isdigit (buf[1]) && isdigit (buf[2]))
4748         {
4749           error ("Protocol error with Rcmd");
4750         }
4751       for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
4752         {
4753           char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
4754           fputc_unfiltered (c, outbuf);
4755         }
4756       break;
4757     }
4758 }
4759
4760 static void
4761 packet_command (char *args, int from_tty)
4762 {
4763   char *buf = alloca (PBUFSIZ);
4764
4765   if (!remote_desc)
4766     error ("command can only be used with remote target");
4767
4768   if (!args)
4769     error ("remote-packet command requires packet text as argument");
4770
4771   puts_filtered ("sending: ");
4772   print_packet (args);
4773   puts_filtered ("\n");
4774   putpkt (args);
4775
4776   getpkt (buf, PBUFSIZ, 0);
4777   puts_filtered ("received: ");
4778   print_packet (buf);
4779   puts_filtered ("\n");
4780 }
4781
4782 #if 0
4783 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
4784
4785 static void display_thread_info (struct gdb_ext_thread_info *info);
4786
4787 static void threadset_test_cmd (char *cmd, int tty);
4788
4789 static void threadalive_test (char *cmd, int tty);
4790
4791 static void threadlist_test_cmd (char *cmd, int tty);
4792
4793 int get_and_display_threadinfo (threadref * ref);
4794
4795 static void threadinfo_test_cmd (char *cmd, int tty);
4796
4797 static int thread_display_step (threadref * ref, void *context);
4798
4799 static void threadlist_update_test_cmd (char *cmd, int tty);
4800
4801 static void init_remote_threadtests (void);
4802
4803 #define SAMPLE_THREAD  0x05060708       /* Truncated 64 bit threadid */
4804
4805 static void
4806 threadset_test_cmd (char *cmd, int tty)
4807 {
4808   int sample_thread = SAMPLE_THREAD;
4809
4810   printf_filtered ("Remote threadset test\n");
4811   set_thread (sample_thread, 1);
4812 }
4813
4814
4815 static void
4816 threadalive_test (char *cmd, int tty)
4817 {
4818   int sample_thread = SAMPLE_THREAD;
4819
4820   if (remote_thread_alive (sample_thread))
4821     printf_filtered ("PASS: Thread alive test\n");
4822   else
4823     printf_filtered ("FAIL: Thread alive test\n");
4824 }
4825
4826 void output_threadid (char *title, threadref * ref);
4827
4828 void
4829 output_threadid (char *title, threadref *ref)
4830 {
4831   char hexid[20];
4832
4833   pack_threadid (&hexid[0], ref);       /* Convert threead id into hex */
4834   hexid[16] = 0;
4835   printf_filtered ("%s  %s\n", title, (&hexid[0]));
4836 }
4837
4838 static void
4839 threadlist_test_cmd (char *cmd, int tty)
4840 {
4841   int startflag = 1;
4842   threadref nextthread;
4843   int done, result_count;
4844   threadref threadlist[3];
4845
4846   printf_filtered ("Remote Threadlist test\n");
4847   if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
4848                               &result_count, &threadlist[0]))
4849     printf_filtered ("FAIL: threadlist test\n");
4850   else
4851     {
4852       threadref *scan = threadlist;
4853       threadref *limit = scan + result_count;
4854
4855       while (scan < limit)
4856         output_threadid (" thread ", scan++);
4857     }
4858 }
4859
4860 void
4861 display_thread_info (struct gdb_ext_thread_info *info)
4862 {
4863   output_threadid ("Threadid: ", &info->threadid);
4864   printf_filtered ("Name: %s\n ", info->shortname);
4865   printf_filtered ("State: %s\n", info->display);
4866   printf_filtered ("other: %s\n\n", info->more_display);
4867 }
4868
4869 int
4870 get_and_display_threadinfo (threadref *ref)
4871 {
4872   int result;
4873   int set;
4874   struct gdb_ext_thread_info threadinfo;
4875
4876   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
4877     | TAG_MOREDISPLAY | TAG_DISPLAY;
4878   if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
4879     display_thread_info (&threadinfo);
4880   return result;
4881 }
4882
4883 static void
4884 threadinfo_test_cmd (char *cmd, int tty)
4885 {
4886   int athread = SAMPLE_THREAD;
4887   threadref thread;
4888   int set;
4889
4890   int_to_threadref (&thread, athread);
4891   printf_filtered ("Remote Threadinfo test\n");
4892   if (!get_and_display_threadinfo (&thread))
4893     printf_filtered ("FAIL cannot get thread info\n");
4894 }
4895
4896 static int
4897 thread_display_step (threadref *ref, void *context)
4898 {
4899   /* output_threadid(" threadstep ",ref); *//* simple test */
4900   return get_and_display_threadinfo (ref);
4901 }
4902
4903 static void
4904 threadlist_update_test_cmd (char *cmd, int tty)
4905 {
4906   printf_filtered ("Remote Threadlist update test\n");
4907   remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
4908 }
4909
4910 static void
4911 init_remote_threadtests (void)
4912 {
4913   add_com ("tlist", class_obscure, threadlist_test_cmd,
4914      "Fetch and print the remote list of thread identifiers, one pkt only");
4915   add_com ("tinfo", class_obscure, threadinfo_test_cmd,
4916            "Fetch and display info about one thread");
4917   add_com ("tset", class_obscure, threadset_test_cmd,
4918            "Test setting to a different thread");
4919   add_com ("tupd", class_obscure, threadlist_update_test_cmd,
4920            "Iterate through updating all remote thread info");
4921   add_com ("talive", class_obscure, threadalive_test,
4922            " Remote thread alive test ");
4923 }
4924
4925 #endif /* 0 */
4926
4927 static void
4928 init_remote_ops (void)
4929 {
4930   remote_ops.to_shortname = "remote";
4931   remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
4932   remote_ops.to_doc =
4933     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
4934 Specify the serial device it is connected to\n\
4935 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
4936   remote_ops.to_open = remote_open;
4937   remote_ops.to_close = remote_close;
4938   remote_ops.to_detach = remote_detach;
4939   remote_ops.to_resume = remote_resume;
4940   remote_ops.to_wait = remote_wait;
4941   remote_ops.to_fetch_registers = remote_fetch_registers;
4942   remote_ops.to_store_registers = remote_store_registers;
4943   remote_ops.to_prepare_to_store = remote_prepare_to_store;
4944   remote_ops.to_xfer_memory = remote_xfer_memory;
4945   remote_ops.to_files_info = remote_files_info;
4946   remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
4947   remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
4948   remote_ops.to_kill = remote_kill;
4949   remote_ops.to_load = generic_load;
4950   remote_ops.to_mourn_inferior = remote_mourn;
4951   remote_ops.to_thread_alive = remote_thread_alive;
4952   remote_ops.to_find_new_threads = remote_threads_info;
4953   remote_ops.to_extra_thread_info = remote_threads_extra_info;
4954   remote_ops.to_stop = remote_stop;
4955   remote_ops.to_query = remote_query;
4956   remote_ops.to_rcmd = remote_rcmd;
4957   remote_ops.to_stratum = process_stratum;
4958   remote_ops.to_has_all_memory = 1;
4959   remote_ops.to_has_memory = 1;
4960   remote_ops.to_has_stack = 1;
4961   remote_ops.to_has_registers = 1;
4962   remote_ops.to_has_execution = 1;
4963   remote_ops.to_has_thread_control = tc_schedlock;      /* can lock scheduler */
4964   remote_ops.to_magic = OPS_MAGIC;
4965 }
4966
4967 /* Set up the extended remote vector by making a copy of the standard
4968    remote vector and adding to it.  */
4969
4970 static void
4971 init_extended_remote_ops (void)
4972 {
4973   extended_remote_ops = remote_ops;
4974
4975   extended_remote_ops.to_shortname = "extended-remote";
4976   extended_remote_ops.to_longname =
4977     "Extended remote serial target in gdb-specific protocol";
4978   extended_remote_ops.to_doc =
4979     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
4980 Specify the serial device it is connected to (e.g. /dev/ttya).",
4981     extended_remote_ops.to_open = extended_remote_open;
4982   extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
4983   extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
4984 }
4985
4986 /*
4987  * Command: info remote-process
4988  *
4989  * This implements Cisco's version of the "info proc" command.
4990  *
4991  * This query allows the target stub to return an arbitrary string
4992  * (or strings) giving arbitrary information about the target process.
4993  * This is optional; the target stub isn't required to implement it.
4994  *
4995  * Syntax: qfProcessInfo        request first string
4996  *         qsProcessInfo        request subsequent string
4997  * reply:  'O'<hex-encoded-string>
4998  *         'l'                  last reply (empty)
4999  */
5000
5001 static void
5002 remote_info_process (char *args, int from_tty)
5003 {
5004   char *buf = alloca (PBUFSIZ);
5005
5006   if (remote_desc == 0)
5007     error ("Command can only be used when connected to the remote target.");
5008
5009   putpkt ("qfProcessInfo");
5010   getpkt (buf, PBUFSIZ, 0);
5011   if (buf[0] == 0)
5012     return;                     /* Silently: target does not support this feature. */
5013
5014   if (buf[0] == 'E')
5015     error ("info proc: target error.");
5016
5017   while (buf[0] == 'O')         /* Capitol-O packet */
5018     {
5019       remote_console_output (&buf[1]);
5020       putpkt ("qsProcessInfo");
5021       getpkt (buf, PBUFSIZ, 0);
5022     }
5023 }
5024
5025 /*
5026  * Target Cisco
5027  */
5028
5029 static void
5030 remote_cisco_open (char *name, int from_tty)
5031 {
5032   if (name == 0)
5033     error (
5034             "To open a remote debug connection, you need to specify what \n\
5035 device is attached to the remote system (e.g. host:port).");
5036
5037   /* See FIXME above */
5038   wait_forever_enabled_p = 1;
5039
5040   target_preopen (from_tty);
5041
5042   unpush_target (&remote_cisco_ops);
5043
5044   remote_desc = SERIAL_OPEN (name);
5045   if (!remote_desc)
5046     perror_with_name (name);
5047
5048   /*
5049    * If a baud rate was specified on the gdb  command line it will
5050    * be greater than the initial value of -1.  If it is, use it otherwise
5051    * default to 9600
5052    */
5053
5054   baud_rate = (baud_rate > 0) ? baud_rate : 9600;
5055   if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
5056     {
5057       SERIAL_CLOSE (remote_desc);
5058       perror_with_name (name);
5059     }
5060
5061   SERIAL_RAW (remote_desc);
5062
5063   /* If there is something sitting in the buffer we might take it as a
5064      response to a command, which would be bad.  */
5065   SERIAL_FLUSH_INPUT (remote_desc);
5066
5067   if (from_tty)
5068     {
5069       puts_filtered ("Remote debugging using ");
5070       puts_filtered (name);
5071       puts_filtered ("\n");
5072     }
5073
5074   remote_cisco_mode = 1;
5075
5076   push_target (&remote_cisco_ops);      /* Switch to using cisco target now */
5077
5078   init_all_packet_configs ();
5079
5080   general_thread = -2;
5081   continue_thread = -2;
5082
5083   /* Probe for ability to use "ThreadInfo" query, as required.  */
5084   use_threadinfo_query = 1;
5085   use_threadextra_query = 1;
5086
5087   /* Without this, some commands which require an active target (such
5088      as kill) won't work.  This variable serves (at least) double duty
5089      as both the pid of the target process (if it has such), and as a
5090      flag indicating that a target is active.  These functions should
5091      be split out into seperate variables, especially since GDB will
5092      someday have a notion of debugging several processes.  */
5093   inferior_pid = MAGIC_NULL_PID;
5094
5095   /* Start the remote connection; if error (0), discard this target. */
5096
5097   if (!catch_errors (remote_start_remote_dummy, (char *) 0,
5098                      "Couldn't establish connection to remote target\n",
5099                      RETURN_MASK_ALL))
5100     {
5101       pop_target ();
5102       return;
5103     }
5104 }
5105
5106 static void
5107 remote_cisco_close (int quitting)
5108 {
5109   remote_cisco_mode = 0;
5110   remote_close (quitting);
5111 }
5112
5113 static void
5114 remote_cisco_mourn (void)
5115 {
5116   remote_mourn_1 (&remote_cisco_ops);
5117 }
5118
5119 enum
5120 {
5121   READ_MORE,
5122   FATAL_ERROR,
5123   ENTER_DEBUG,
5124   DISCONNECT_TELNET
5125 }
5126 minitelnet_return;
5127
5128 /* shared between readsocket() and readtty()  */
5129 static char *tty_input;
5130
5131 static int escape_count;
5132 static int echo_check;
5133 extern int quit_flag;
5134
5135 static int
5136 readsocket (void)
5137 {
5138   int data;
5139
5140   /* Loop until the socket doesn't have any more data */
5141
5142   while ((data = readchar (0)) >= 0)
5143     {
5144       /* Check for the escape sequence */
5145       if (data == '|')
5146         {
5147           /* If this is the fourth escape, get out */
5148           if (++escape_count == 4)
5149             {
5150               return ENTER_DEBUG;
5151             }
5152           else
5153             {                   /* This is a '|', but not the fourth in a row.
5154                                    Continue without echoing it.  If it isn't actually
5155                                    one of four in a row, it'll be echoed later.  */
5156               continue;
5157             }
5158         }
5159       else
5160         /* Not a '|' */
5161         {
5162           /* Ensure any pending '|'s are flushed.  */
5163
5164           for (; escape_count > 0; escape_count--)
5165             putchar ('|');
5166         }
5167
5168       if (data == '\r')         /* If this is a return character, */
5169         continue;               /*  - just supress it. */
5170
5171       if (echo_check != -1)     /* Check for echo of user input.  */
5172         {
5173           if (tty_input[echo_check] == data)
5174             {
5175               echo_check++;     /* Character matched user input: */
5176               continue;         /* Continue without echoing it.  */
5177             }
5178           else if ((data == '\n') && (tty_input[echo_check] == '\r'))
5179             {                   /* End of the line (and of echo checking).  */
5180               echo_check = -1;  /* No more echo supression */
5181               continue;         /* Continue without echoing.  */
5182             }
5183           else
5184             {                   /* Failed check for echo of user input.
5185                                    We now have some suppressed output to flush!  */
5186               int j;
5187
5188               for (j = 0; j < echo_check; j++)
5189                 putchar (tty_input[j]);
5190               echo_check = -1;
5191             }
5192         }
5193       putchar (data);           /* Default case: output the char.  */
5194     }
5195
5196   if (data == SERIAL_TIMEOUT)   /* Timeout returned from readchar.  */
5197     return READ_MORE;           /* Try to read some more */
5198   else
5199     return FATAL_ERROR;         /* Trouble, bail out */
5200 }
5201
5202 static int
5203 readtty (void)
5204 {
5205   int tty_bytecount;
5206
5207   /* First, read a buffer full from the terminal */
5208   tty_bytecount = read (fileno (stdin), tty_input, sizeof (tty_input) - 1);
5209   if (tty_bytecount == -1)
5210     {
5211       perror ("readtty: read failed");
5212       return FATAL_ERROR;
5213     }
5214
5215   /* Remove a quoted newline.  */
5216   if (tty_input[tty_bytecount - 1] == '\n' &&
5217       tty_input[tty_bytecount - 2] == '\\')     /* line ending in backslash */
5218     {
5219       tty_input[--tty_bytecount] = 0;   /* remove newline */
5220       tty_input[--tty_bytecount] = 0;   /* remove backslash */
5221     }
5222
5223   /* Turn trailing newlines into returns */
5224   if (tty_input[tty_bytecount - 1] == '\n')
5225     tty_input[tty_bytecount - 1] = '\r';
5226
5227   /* If the line consists of a ~, enter debugging mode.  */
5228   if ((tty_input[0] == '~') && (tty_bytecount == 2))
5229     return ENTER_DEBUG;
5230
5231   /* Make this a zero terminated string and write it out */
5232   tty_input[tty_bytecount] = 0;
5233   if (SERIAL_WRITE (remote_desc, tty_input, tty_bytecount))
5234     {
5235       perror_with_name ("readtty: write failed");
5236       return FATAL_ERROR;
5237     }
5238
5239   return READ_MORE;
5240 }
5241
5242 static int
5243 minitelnet (void)
5244 {
5245   fd_set input;                 /* file descriptors for select */
5246   int tablesize;                /* max number of FDs for select */
5247   int status;
5248   int quit_count = 0;
5249
5250   extern int escape_count;      /* global shared by readsocket */
5251   extern int echo_check;        /* ditto */
5252
5253   escape_count = 0;
5254   echo_check = -1;
5255
5256   tablesize = 8 * sizeof (input);
5257
5258   for (;;)
5259     {
5260       /* Check for anything from our socket - doesn't block. Note that
5261          this must be done *before* the select as there may be
5262          buffered I/O waiting to be processed.  */
5263
5264       if ((status = readsocket ()) == FATAL_ERROR)
5265         {
5266           error ("Debugging terminated by communications error");
5267         }
5268       else if (status != READ_MORE)
5269         {
5270           return (status);
5271         }
5272
5273       fflush (stdout);          /* Flush output before blocking */
5274
5275       /* Now block on more socket input or TTY input */
5276
5277       FD_ZERO (&input);
5278       FD_SET (fileno (stdin), &input);
5279       FD_SET (DEPRECATED_SERIAL_FD (remote_desc), &input);
5280
5281       status = select (tablesize, &input, 0, 0, 0);
5282       if ((status == -1) && (errno != EINTR))
5283         {
5284           error ("Communications error on select %d", errno);
5285         }
5286
5287       /* Handle Control-C typed */
5288
5289       if (quit_flag)
5290         {
5291           if ((++quit_count) == 2)
5292             {
5293               if (query ("Interrupt GDB? "))
5294                 {
5295                   printf_filtered ("Interrupted by user.\n");
5296                   return_to_top_level (RETURN_QUIT);
5297                 }
5298               quit_count = 0;
5299             }
5300           quit_flag = 0;
5301
5302           if (remote_break)
5303             SERIAL_SEND_BREAK (remote_desc);
5304           else
5305             SERIAL_WRITE (remote_desc, "\003", 1);
5306
5307           continue;
5308         }
5309
5310       /* Handle console input */
5311
5312       if (FD_ISSET (fileno (stdin), &input))
5313         {
5314           quit_count = 0;
5315           echo_check = 0;
5316           status = readtty ();
5317           if (status == READ_MORE)
5318             continue;
5319
5320           return status;        /* telnet session ended */
5321         }
5322     }
5323 }
5324
5325 static int
5326 remote_cisco_wait (int pid, struct target_waitstatus *status)
5327 {
5328   if (minitelnet () != ENTER_DEBUG)
5329     {
5330       error ("Debugging session terminated by protocol error");
5331     }
5332   putpkt ("?");
5333   return remote_wait (pid, status);
5334 }
5335
5336 static void
5337 init_remote_cisco_ops (void)
5338 {
5339   remote_cisco_ops.to_shortname = "cisco";
5340   remote_cisco_ops.to_longname = "Remote serial target in cisco-specific protocol";
5341   remote_cisco_ops.to_doc =
5342     "Use a remote machine via TCP, using a cisco-specific protocol.\n\
5343 Specify the serial device it is connected to (e.g. host:2020).";
5344   remote_cisco_ops.to_open = remote_cisco_open;
5345   remote_cisco_ops.to_close = remote_cisco_close;
5346   remote_cisco_ops.to_detach = remote_detach;
5347   remote_cisco_ops.to_resume = remote_resume;
5348   remote_cisco_ops.to_wait = remote_cisco_wait;
5349   remote_cisco_ops.to_fetch_registers = remote_fetch_registers;
5350   remote_cisco_ops.to_store_registers = remote_store_registers;
5351   remote_cisco_ops.to_prepare_to_store = remote_prepare_to_store;
5352   remote_cisco_ops.to_xfer_memory = remote_xfer_memory;
5353   remote_cisco_ops.to_files_info = remote_files_info;
5354   remote_cisco_ops.to_insert_breakpoint = remote_insert_breakpoint;
5355   remote_cisco_ops.to_remove_breakpoint = remote_remove_breakpoint;
5356   remote_cisco_ops.to_kill = remote_kill;
5357   remote_cisco_ops.to_load = generic_load;
5358   remote_cisco_ops.to_mourn_inferior = remote_cisco_mourn;
5359   remote_cisco_ops.to_thread_alive = remote_thread_alive;
5360   remote_cisco_ops.to_find_new_threads = remote_threads_info;
5361   remote_ops.to_extra_thread_info = remote_threads_extra_info;
5362   remote_cisco_ops.to_stratum = process_stratum;
5363   remote_cisco_ops.to_has_all_memory = 1;
5364   remote_cisco_ops.to_has_memory = 1;
5365   remote_cisco_ops.to_has_stack = 1;
5366   remote_cisco_ops.to_has_registers = 1;
5367   remote_cisco_ops.to_has_execution = 1;
5368   remote_cisco_ops.to_magic = OPS_MAGIC;
5369 }
5370
5371 static int
5372 remote_can_async_p (void)
5373 {
5374   /* We're async whenever the serial device is. */
5375   return (current_target.to_async_mask_value) && SERIAL_CAN_ASYNC_P (remote_desc);
5376 }
5377
5378 static int
5379 remote_is_async_p (void)
5380 {
5381   /* We're async whenever the serial device is. */
5382   return (current_target.to_async_mask_value) && SERIAL_IS_ASYNC_P (remote_desc);
5383 }
5384
5385 /* Pass the SERIAL event on and up to the client.  One day this code
5386    will be able to delay notifying the client of an event until the
5387    point where an entire packet has been received. */
5388
5389 static void (*async_client_callback) (enum inferior_event_type event_type, void *context);
5390 static void *async_client_context;
5391 static serial_event_ftype remote_async_serial_handler;
5392
5393 static void
5394 remote_async_serial_handler (serial_t scb, void *context)
5395 {
5396   /* Don't propogate error information up to the client.  Instead let
5397      the client find out about the error by querying the target.  */
5398   async_client_callback (INF_REG_EVENT, async_client_context);
5399 }
5400
5401 static void
5402 remote_async (void (*callback) (enum inferior_event_type event_type, void *context), void *context)
5403 {
5404   if (current_target.to_async_mask_value == 0)
5405     internal_error ("Calling remote_async when async is masked");
5406
5407   if (callback != NULL)
5408     {
5409       SERIAL_ASYNC (remote_desc, remote_async_serial_handler, NULL);
5410       async_client_callback = callback;
5411       async_client_context = context;
5412     }
5413   else
5414     SERIAL_ASYNC (remote_desc, NULL, NULL);
5415 }
5416
5417 /* Target async and target extended-async.
5418
5419    This are temporary targets, until it is all tested.  Eventually
5420    async support will be incorporated int the usual 'remote'
5421    target. */
5422
5423 static void
5424 init_remote_async_ops (void)
5425 {
5426   remote_async_ops.to_shortname = "async";
5427   remote_async_ops.to_longname = "Remote serial target in async version of the gdb-specific protocol";
5428   remote_async_ops.to_doc =
5429     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5430 Specify the serial device it is connected to (e.g. /dev/ttya).";
5431   remote_async_ops.to_open = remote_async_open;
5432   remote_async_ops.to_close = remote_close;
5433   remote_async_ops.to_detach = remote_async_detach;
5434   remote_async_ops.to_resume = remote_async_resume;
5435   remote_async_ops.to_wait = remote_async_wait;
5436   remote_async_ops.to_fetch_registers = remote_fetch_registers;
5437   remote_async_ops.to_store_registers = remote_store_registers;
5438   remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
5439   remote_async_ops.to_xfer_memory = remote_xfer_memory;
5440   remote_async_ops.to_files_info = remote_files_info;
5441   remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
5442   remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
5443   remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
5444   remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
5445   remote_async_ops.to_kill = remote_async_kill;
5446   remote_async_ops.to_load = generic_load;
5447   remote_async_ops.to_mourn_inferior = remote_async_mourn;
5448   remote_async_ops.to_thread_alive = remote_thread_alive;
5449   remote_async_ops.to_find_new_threads = remote_threads_info;
5450   remote_ops.to_extra_thread_info = remote_threads_extra_info;
5451   remote_async_ops.to_stop = remote_stop;
5452   remote_async_ops.to_query = remote_query;
5453   remote_async_ops.to_rcmd = remote_rcmd;
5454   remote_async_ops.to_stratum = process_stratum;
5455   remote_async_ops.to_has_all_memory = 1;
5456   remote_async_ops.to_has_memory = 1;
5457   remote_async_ops.to_has_stack = 1;
5458   remote_async_ops.to_has_registers = 1;
5459   remote_async_ops.to_has_execution = 1;
5460   remote_async_ops.to_has_thread_control = tc_schedlock;        /* can lock scheduler */
5461   remote_async_ops.to_can_async_p = remote_can_async_p;
5462   remote_async_ops.to_is_async_p = remote_is_async_p;
5463   remote_async_ops.to_async = remote_async;
5464   remote_async_ops.to_async_mask_value = 1;
5465   remote_async_ops.to_magic = OPS_MAGIC;
5466 }
5467
5468 /* Set up the async extended remote vector by making a copy of the standard
5469    remote vector and adding to it.  */
5470
5471 static void
5472 init_extended_async_remote_ops (void)
5473 {
5474   extended_async_remote_ops = remote_async_ops;
5475
5476   extended_async_remote_ops.to_shortname = "extended-async";
5477   extended_async_remote_ops.to_longname =
5478     "Extended remote serial target in async gdb-specific protocol";
5479   extended_async_remote_ops.to_doc =
5480     "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5481 Specify the serial device it is connected to (e.g. /dev/ttya).",
5482     extended_async_remote_ops.to_open = extended_remote_async_open;
5483   extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
5484   extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
5485 }
5486
5487 static void
5488 set_remote_cmd (char *args, int from_tty)
5489 {
5490
5491 }
5492
5493 static void
5494 show_remote_cmd (char *args, int from_tty)
5495 {
5496   show_remote_protocol_Z_packet_cmd (args, from_tty);
5497   show_remote_protocol_P_packet_cmd (args, from_tty);
5498   show_remote_protocol_binary_download_cmd (args, from_tty);
5499 }
5500
5501 static void
5502 build_remote_gdbarch_data (void)
5503 {
5504   build_remote_packet_sizes ();
5505
5506   /* Cisco stuff */
5507   tty_input = xmalloc (PBUFSIZ);
5508   remote_address_size = TARGET_PTR_BIT;
5509 }
5510
5511 void
5512 _initialize_remote (void)
5513 {
5514   static struct cmd_list_element *remote_set_cmdlist;
5515   static struct cmd_list_element *remote_show_cmdlist;
5516   struct cmd_list_element *tmpcmd;
5517
5518   /* architecture specific data */
5519   build_remote_gdbarch_data ();
5520   register_gdbarch_swap (&tty_input, sizeof (&tty_input), NULL);
5521   register_remote_packet_sizes ();
5522   register_gdbarch_swap (&remote_address_size,
5523                          sizeof (&remote_address_size), NULL);
5524   register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
5525
5526   init_remote_ops ();
5527   add_target (&remote_ops);
5528
5529   init_extended_remote_ops ();
5530   add_target (&extended_remote_ops);
5531
5532   init_remote_async_ops ();
5533   add_target (&remote_async_ops);
5534
5535   init_extended_async_remote_ops ();
5536   add_target (&extended_async_remote_ops);
5537
5538   init_remote_cisco_ops ();
5539   add_target (&remote_cisco_ops);
5540
5541 #if 0
5542   init_remote_threadtests ();
5543 #endif
5544
5545   /* set/show remote ... */
5546
5547   add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
5548 Remote protocol specific variables\n\
5549 Configure various remote-protocol specific variables such as\n\
5550 the packets being used",
5551                   &remote_set_cmdlist, "set remote ",
5552                   0/*allow-unknown*/, &setlist);
5553   add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, "\
5554 Remote protocol specific variables\n\
5555 Configure various remote-protocol specific variables such as\n\
5556 the packets being used",
5557                   &remote_show_cmdlist, "show remote ",
5558                   0/*allow-unknown*/, &showlist);
5559
5560   add_cmd ("compare-sections", class_obscure, compare_sections_command,
5561            "Compare section data on target to the exec file.\n\
5562 Argument is a single section name (default: all loaded sections).",
5563            &cmdlist);
5564
5565   add_cmd ("packet", class_maintenance, packet_command,
5566            "Send an arbitrary packet to a remote target.\n\
5567    maintenance packet TEXT\n\
5568 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5569 this command sends the string TEXT to the inferior, and displays the\n\
5570 response packet.  GDB supplies the initial `$' character, and the\n\
5571 terminating `#' character and checksum.",
5572            &maintenancelist);
5573
5574   add_show_from_set
5575     (add_set_cmd ("remotebreak", no_class,
5576                   var_boolean, (char *) &remote_break,
5577                   "Set whether to send break if interrupted.\n",
5578                   &setlist),
5579      &showlist);
5580
5581   /* Install commands for configuring memory read/write packets. */
5582
5583   add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
5584            "Set the maximum number of bytes per memory write packet (deprecated).\n",
5585            &setlist);
5586   add_cmd ("remotewritesize", no_class, show_memory_write_packet_size,
5587            "Show the maximum number of bytes per memory write packet (deprecated).\n",
5588            &showlist);
5589   add_cmd ("memory-write-packet-size", no_class,
5590            set_memory_write_packet_size,
5591            "Set the maximum number of bytes per memory-write packet.\n"
5592            "Specify the number of bytes in a packet or 0 (zero) for the\n"
5593            "default packet size.  The actual limit is further reduced\n"
5594            "dependent on the target.  Specify ``fixed'' to disable the\n"
5595            "further restriction and ``limit'' to enable that restriction\n",
5596            &remote_set_cmdlist);
5597   add_cmd ("memory-read-packet-size", no_class,
5598            set_memory_read_packet_size,
5599            "Set the maximum number of bytes per memory-read packet.\n"
5600            "Specify the number of bytes in a packet or 0 (zero) for the\n"
5601            "default packet size.  The actual limit is further reduced\n"
5602            "dependent on the target.  Specify ``fixed'' to disable the\n"
5603            "further restriction and ``limit'' to enable that restriction\n",
5604            &remote_set_cmdlist);
5605   add_cmd ("memory-write-packet-size", no_class,
5606            show_memory_write_packet_size,
5607            "Show the maximum number of bytes per memory-write packet.\n",
5608            &remote_show_cmdlist);
5609   add_cmd ("memory-read-packet-size", no_class,
5610            show_memory_read_packet_size,
5611            "Show the maximum number of bytes per memory-read packet.\n",
5612            &remote_show_cmdlist);
5613
5614   add_show_from_set
5615     (add_set_cmd ("remoteaddresssize", class_obscure,
5616                   var_integer, (char *) &remote_address_size,
5617                   "Set the maximum size of the address (in bits) \
5618 in a memory packet.\n",
5619                   &setlist),
5620      &showlist);
5621
5622   add_packet_config_cmd (&remote_protocol_binary_download,
5623                          "X", "binary-download",
5624                          set_remote_protocol_binary_download_cmd,
5625                          show_remote_protocol_binary_download_cmd,
5626                          &remote_set_cmdlist, &remote_show_cmdlist,
5627                          1);
5628 #if 0
5629   /* XXXX - should ``set remotebinarydownload'' be retained for
5630      compatibility. */
5631   add_show_from_set
5632     (add_set_cmd ("remotebinarydownload", no_class,
5633                   var_boolean, (char *) &remote_binary_download,
5634                   "Set binary downloads.\n", &setlist),
5635      &showlist);
5636 #endif
5637
5638   add_info ("remote-process", remote_info_process,
5639             "Query the remote system for process info.");
5640
5641   add_packet_config_cmd (&remote_protocol_P,
5642                          "P", "set-register",
5643                          set_remote_protocol_P_packet_cmd,
5644                          show_remote_protocol_P_packet_cmd,
5645                          &remote_set_cmdlist, &remote_show_cmdlist,
5646                          1);
5647
5648   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
5649                          "Z0", "software-breakpoint",
5650                          set_remote_protocol_Z_software_bp_packet_cmd,
5651                          show_remote_protocol_Z_software_bp_packet_cmd,
5652                          &remote_set_cmdlist, &remote_show_cmdlist,
5653                          0);
5654
5655   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
5656                          "Z1", "hardware-breakpoint",
5657                          set_remote_protocol_Z_hardware_bp_packet_cmd,
5658                          show_remote_protocol_Z_hardware_bp_packet_cmd,
5659                          &remote_set_cmdlist, &remote_show_cmdlist,
5660                          0);
5661
5662   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
5663                          "Z2", "write-watchpoint",
5664                          set_remote_protocol_Z_write_wp_packet_cmd,
5665                          show_remote_protocol_Z_write_wp_packet_cmd,
5666                          &remote_set_cmdlist, &remote_show_cmdlist,
5667                          0);
5668
5669   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
5670                          "Z3", "read-watchpoint",
5671                          set_remote_protocol_Z_read_wp_packet_cmd,
5672                          show_remote_protocol_Z_read_wp_packet_cmd,
5673                          &remote_set_cmdlist, &remote_show_cmdlist,
5674                          0);
5675
5676   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
5677                          "Z4", "access-watchpoint",
5678                          set_remote_protocol_Z_access_wp_packet_cmd,
5679                          show_remote_protocol_Z_access_wp_packet_cmd,
5680                          &remote_set_cmdlist, &remote_show_cmdlist,
5681                          0);
5682
5683   /* Keep the old ``set remote Z-packet ...'' working. */
5684   tmpcmd = add_set_auto_boolean_cmd ("Z-packet", class_obscure,
5685                                      &remote_Z_packet_detect,
5686                                      "\
5687 Set use of remote protocol `Z' packets", &remote_set_cmdlist);
5688   tmpcmd->function.sfunc = set_remote_protocol_Z_packet_cmd;
5689   add_cmd ("Z-packet", class_obscure, show_remote_protocol_Z_packet_cmd,
5690            "Show use of remote protocol `Z' packets ",
5691            &remote_show_cmdlist);
5692 }