gdb/remote.c

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