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