gdb/remote.c

   1 /* Remote target communications for serial-line targets in custom GDB protocol
   2    Copyright 1988, 1991, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* Remote communication protocol.
  21    All values are encoded in ascii hex digits.
  22
  23         Request         Packet
  24
  25         read registers  g
  26         reply           XX....X         Each byte of register data
  27                                         is described by two hex digits.
  28                                         Registers are in the internal order
  29                                         for GDB, and the bytes in a register
  30                                         are in the same order the machine uses.
  31                         or ENN          for an error.
  32
  33         write regs      GXX..XX         Each byte of register data
  34                                         is described by two hex digits.
  35         reply           OK              for success
  36                         ENN             for an error
  37
  38         read mem        mAA..AA,LLLL    AA..AA is address, LLLL is length.
  39         reply           XX..XX          XX..XX is mem contents
  40                         or ENN          NN is errno
  41
  42         write mem       MAA..AA,LLLL:XX..XX
  43                                         AA..AA is address,
  44                                         LLLL is number of bytes,
  45                                         XX..XX is data
  46         reply           OK              for success
  47                         ENN             for an error
  48
  49         cont            cAA..AA         AA..AA is address to resume
  50                                         If AA..AA is omitted,
  51                                         resume at same address.
  52
  53         step            sAA..AA         AA..AA is address to resume
  54                                         If AA..AA is omitted,
  55                                         resume at same address.
  56
  57         last signal     ?               Reply the current reason for stopping.
  58                                         This is the same reply as is generated
  59                                         for step or cont : SAA where AA is the
  60                                         signal number.
  61
  62         There is no immediate reply to step or cont.
  63         The reply comes when the machine stops.
  64         It is           SAA             AA is the "signal number"
  65
  66         or...           TAAPPPPPPPPFFFFFFFF
  67                                         where AA is the signal number,
  68                                         PPPPPPPP is the PC (PC_REGNUM), and
  69                                         FFFFFFFF is the frame ptr (FP_REGNUM).
  70
  71         kill req        k
  72 */
  73
  74 #include "defs.h"
  75 #include <string.h>
  76 #include <fcntl.h>
  77 #include "frame.h"
  78 #include "inferior.h"
  79 #include "target.h"
  80 #include "wait.h"
  81 #include "terminal.h"
  82 #include "gdbcmd.h"
  83
  84 #if !defined(DONT_USE_REMOTE)
  85 #ifdef USG
  86 #include <sys/types.h>
  87 #endif
  88
  89 #include <signal.h>
  90
  91 /* Prototypes for local functions */
  92
  93 static void
  94 remote_write_bytes PARAMS ((CORE_ADDR, char *, int));
  95
  96 static void
  97 remote_read_bytes PARAMS ((CORE_ADDR, char *, int));
  98
  99 static void
 100 remote_files_info PARAMS ((struct target_ops *));
 101
 102 static int
 103 remote_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 104
 105 static void
 106 remote_prepare_to_store PARAMS ((void));
 107
 108 static void
 109 remote_fetch_registers PARAMS ((int));
 110
 111 static void
 112 remote_resume PARAMS ((int, int));
 113
 114 static void
 115 remote_open PARAMS ((char *, int));
 116
 117 static void
 118 remote_close PARAMS ((int));
 119
 120 static void
 121 remote_store_registers PARAMS ((int));
 122
 123 static void
 124 getpkt PARAMS ((char *));
 125
 126 static void
 127 putpkt PARAMS ((char *));
 128
 129 static void
 130 remote_send PARAMS ((char *));
 131
 132 static int
 133 readchar PARAMS ((void));
 134
 135 static int
 136 remote_wait PARAMS ((WAITTYPE *));
 137
 138 static int
 139 tohex PARAMS ((int));
 140
 141 static int
 142 fromhex PARAMS ((int));
 143
 144 static void
 145 remote_detach PARAMS ((char *, int));
 146
 147
 148 extern struct target_ops remote_ops;    /* Forward decl */
 149
 150 static int kiodebug = 0;
 151 static int timeout = 5;
 152
 153 #if 0
 154 int icache;
 155 #endif
 156
 157 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
 158    remote_open knows that we don't have a file open when the program
 159    starts.  */
 160 int remote_desc = -1;
 161
 162 #define PBUFSIZ 1024
 163
 164 /* Maximum number of bytes to read/write at once.  The value here
 165    is chosen to fill up a packet (the headers account for the 32).  */
 166 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
 167
 168 /* Round up PBUFSIZ to hold all the registers, at least.  */
 169 #if REGISTER_BYTES > MAXBUFBYTES
 170 #undef  PBUFSIZ
 171 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
 172 #endif
 173 \f
 174 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 175 #ifndef HAVE_TERMIO
 176 void
 177 remote_timer (signo)
 178      int signo;
 179 {
 180   if (kiodebug)
 181     printf ("remote_timer called\n");
 182
 183   alarm (timeout);
 184 }
 185 #endif
 186
 187 /* Clean up connection to a remote debugger.  */
 188
 189 /* ARGSUSED */
 190 static void
 191 remote_close (quitting)
 192      int quitting;
 193 {
 194   if (remote_desc >= 0)
 195     close (remote_desc);
 196   remote_desc = -1;
 197 }
 198
 199 /* Translate baud rates from integers to damn B_codes.  Unix should
 200    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 201
 202 #ifndef B19200
 203 #define B19200 EXTA
 204 #endif
 205 #ifndef B38400
 206 #define B38400 EXTB
 207 #endif
 208
 209
 210
 211 static struct {int rate, damn_b;} baudtab[] = {
 212         {0, B0},
 213         {50, B50},
 214         {75, B75},
 215         {110, B110},
 216         {134, B134},
 217         {150, B150},
 218         {200, B200},
 219         {300, B300},
 220         {600, B600},
 221         {1200, B1200},
 222         {1800, B1800},
 223         {2400, B2400},
 224         {4800, B4800},
 225         {9600, B9600},
 226         {19200, B19200},
 227         {38400, B38400},
 228         {-1, -1},
 229 };
 230
 231 static int
 232 damn_b (rate)
 233      int rate;
 234 {
 235   int i;
 236
 237   for (i = 0; baudtab[i].rate != -1; i++)
 238     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
 239   return B38400;        /* Random */
 240 }
 241
 242 /* Open a connection to a remote debugger.
 243    NAME is the filename used for communication.  */
 244
 245 static void
 246 remote_open (name, from_tty)
 247      char *name;
 248      int from_tty;
 249 {
 250   TERMINAL sg;
 251   int a_rate, b_rate = 0;
 252   int baudrate_set = 0;
 253
 254   if (name == 0)
 255     error (
 256 "To open a remote debug connection, you need to specify what serial\n\
 257 device is attached to the remote system (e.g. /dev/ttya).");
 258
 259   target_preopen (from_tty);
 260
 261   remote_close (0);
 262
 263 #if 0
 264   dcache_init ();
 265 #endif
 266
 267   remote_desc = open (name, O_RDWR);
 268   if (remote_desc < 0)
 269     perror_with_name (name);
 270
 271   if (baud_rate)
 272     {
 273       if (sscanf (baud_rate, "%d", &a_rate) == 1)
 274         {
 275           b_rate = damn_b (a_rate);
 276           baudrate_set = 1;
 277         }
 278     }
 279
 280   ioctl (remote_desc, TIOCGETP, &sg);
 281 #ifdef HAVE_TERMIO
 282   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 283   sg.c_cc[VTIME] = timeout * 10;
 284   sg.c_lflag &= ~(ICANON | ECHO);
 285   sg.c_cflag &= ~PARENB;        /* No parity */
 286   sg.c_cflag |= CS8;            /* 8-bit path */
 287   if (baudrate_set)
 288     sg.c_cflag = (sg.c_cflag & ~CBAUD) | b_rate;
 289 #else
 290   sg.sg_flags |= RAW | ANYP;
 291   sg.sg_flags &= ~ECHO;
 292   if (baudrate_set)
 293     {
 294       sg.sg_ispeed = b_rate;
 295       sg.sg_ospeed = b_rate;
 296     }
 297 #endif
 298   ioctl (remote_desc, TIOCSETP, &sg);
 299
 300   if (from_tty)
 301     printf ("Remote debugging using %s\n", name);
 302   push_target (&remote_ops);    /* Switch to using remote target now */
 303
 304 #ifndef HAVE_TERMIO
 305 #ifndef NO_SIGINTERRUPT
 306   /* Cause SIGALRM's to make reads fail.  */
 307   if (siginterrupt (SIGALRM, 1) != 0)
 308     perror ("remote_open: error in siginterrupt");
 309 #endif
 310
 311   /* Set up read timeout timer.  */
 312   if ((void (*)()) signal (SIGALRM, remote_timer) == (void (*)()) -1)
 313     perror ("remote_open: error in signal");
 314 #endif
 315
 316   /* Ack any packet which the remote side has already sent.  */
 317   write (remote_desc, "+\r", 2);
 318   putpkt ("?");                 /* initiate a query from remote machine */
 319
 320   start_remote ();              /* Initialize gdb process mechanisms */
 321 }
 322
 323 /* remote_detach()
 324    takes a program previously attached to and detaches it.
 325    We better not have left any breakpoints
 326    in the program or it'll die when it hits one.
 327    Close the open connection to the remote debugger.
 328    Use this when you want to detach and do something else
 329    with your gdb.  */
 330
 331 static void
 332 remote_detach (args, from_tty)
 333      char *args;
 334      int from_tty;
 335 {
 336   if (args)
 337     error ("Argument given to \"detach\" when remotely debugging.");
 338
 339   pop_target ();
 340   if (from_tty)
 341     printf ("Ending remote debugging.\n");
 342 }
 343
 344 /* Convert hex digit A to a number.  */
 345
 346 static int
 347 fromhex (a)
 348      int a;
 349 {
 350   if (a >= '0' && a <= '9')
 351     return a - '0';
 352   else if (a >= 'a' && a <= 'f')
 353     return a - 'a' + 10;
 354   else
 355     error ("Reply contains invalid hex digit");
 356   return -1;
 357 }
 358
 359 /* Convert number NIB to a hex digit.  */
 360
 361 static int
 362 tohex (nib)
 363      int nib;
 364 {
 365   if (nib < 10)
 366     return '0'+nib;
 367   else
 368     return 'a'+nib-10;
 369 }
 370 \f
 371 /* Tell the remote machine to resume.  */
 372
 373 static void
 374 remote_resume (step, siggnal)
 375      int step, siggnal;
 376 {
 377   char buf[PBUFSIZ];
 378
 379   if (siggnal)
 380     error ("Can't send signals to a remote system.  Try `handle %d ignore'.",
 381            siggnal);
 382
 383 #if 0
 384   dcache_flush ();
 385 #endif
 386
 387   strcpy (buf, step ? "s": "c");
 388
 389   putpkt (buf);
 390 }
 391
 392 /* Send ^C to target to halt it.  Target will respond, and send us a
 393    packet.  */
 394
 395 void remote_interrupt(signo)
 396      int signo;
 397 {
 398
 399   if (kiodebug)
 400     printf ("remote_interrupt called\n");
 401
 402   write (remote_desc, "\003", 1);       /* Send a ^C */
 403 }
 404
 405
 406 /* Wait until the remote machine stops, then return,
 407    storing status in STATUS just as `wait' would.
 408    Returns "pid" (though it's not clear what, if anything, that
 409    means in the case of this target).  */
 410
 411 static int
 412 remote_wait (status)
 413      WAITTYPE *status;
 414 {
 415   unsigned char buf[PBUFSIZ];
 416   void (*ofunc)();
 417   unsigned char *p;
 418   int i;
 419   long regno;
 420   unsigned char regs[MAX_REGISTER_RAW_SIZE];
 421
 422   WSETEXIT ((*status), 0);
 423
 424   ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
 425   getpkt ((char *) buf);
 426   signal (SIGINT, ofunc);
 427
 428   if (buf[0] == 'E')
 429     error ("Remote failure reply: %s", buf);
 430   if (buf[0] == 'T')
 431     {
 432       /* Expedited reply, containing Signal, {regno, reg} repeat */
 433       /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
 434           ss = signal number
 435           n... = register number
 436           r... = register contents
 437           */
 438
 439       p = &buf[3];              /* after Txx */
 440
 441       while (*p)
 442         {
 443           regno = strtol (p, &p, 16); /* Read the register number */
 444
 445           if (*p++ != ':'
 446               || regno >= NUM_REGS)
 447             error ("Remote sent bad register number %s", buf);
 448
 449           for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
 450             {
 451               if (p[0] == 0 || p[1] == 0)
 452                 error ("Remote reply is too short: %s", buf);
 453               regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 454               p += 2;
 455             }
 456
 457           if (*p++ != ';')
 458             error("Remote register badly formatted: %s", buf);
 459
 460           supply_register (regno, regs);
 461         }
 462     }
 463   else if (buf[0] != 'S')
 464     error ("Invalid remote reply: %s", buf);
 465
 466   WSETSTOP ((*status), (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))));
 467
 468   return 0;
 469 }
 470
 471 /* Read the remote registers into the block REGS.  */
 472 /* Currently we just read all the registers, so we don't use regno.  */
 473 /* ARGSUSED */
 474 static void
 475 remote_fetch_registers (regno)
 476      int regno;
 477 {
 478   char buf[PBUFSIZ];
 479   int i;
 480   char *p;
 481   char regs[REGISTER_BYTES];
 482
 483   sprintf (buf, "g");
 484   remote_send (buf);
 485
 486   /* Reply describes registers byte by byte, each byte encoded as two
 487      hex characters.  Suck them all up, then supply them to the
 488      register cacheing/storage mechanism.  */
 489
 490   p = buf;
 491   for (i = 0; i < REGISTER_BYTES; i++)
 492     {
 493       if (p[0] == 0 || p[1] == 0)
 494         error ("Remote reply is too short: %s", buf);
 495       regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 496       p += 2;
 497     }
 498   for (i = 0; i < NUM_REGS; i++)
 499     supply_register (i, &regs[REGISTER_BYTE(i)]);
 500 }
 501
 502 /* Prepare to store registers.  Since we send them all, we have to
 503    read out the ones we don't want to change first.  */
 504
 505 static void
 506 remote_prepare_to_store ()
 507 {
 508   remote_fetch_registers (-1);
 509 }
 510
 511 /* Store the remote registers from the contents of the block REGISTERS.
 512    FIXME, eventually just store one register if that's all that is needed.  */
 513
 514 /* ARGSUSED */
 515 static void
 516 remote_store_registers (regno)
 517      int regno;
 518 {
 519   char buf[PBUFSIZ];
 520   int i;
 521   char *p;
 522
 523   buf[0] = 'G';
 524
 525   /* Command describes registers byte by byte,
 526      each byte encoded as two hex characters.  */
 527
 528   p = buf + 1;
 529   for (i = 0; i < REGISTER_BYTES; i++)
 530     {
 531       *p++ = tohex ((registers[i] >> 4) & 0xf);
 532       *p++ = tohex (registers[i] & 0xf);
 533     }
 534   *p = '\0';
 535
 536   remote_send (buf);
 537 }
 538
 539 #if 0
 540 /* Read a word from remote address ADDR and return it.
 541    This goes through the data cache.  */
 542
 543 int
 544 remote_fetch_word (addr)
 545      CORE_ADDR addr;
 546 {
 547   if (icache)
 548     {
 549       extern CORE_ADDR text_start, text_end;
 550
 551       if (addr >= text_start && addr < text_end)
 552         {
 553           int buffer;
 554           xfer_core_file (addr, &buffer, sizeof (int));
 555           return buffer;
 556         }
 557     }
 558   return dcache_fetch (addr);
 559 }
 560
 561 /* Write a word WORD into remote address ADDR.
 562    This goes through the data cache.  */
 563
 564 void
 565 remote_store_word (addr, word)
 566      CORE_ADDR addr;
 567      int word;
 568 {
 569   dcache_poke (addr, word);
 570 }
 571 #endif /* 0 */
 572 \f
 573 /* Write memory data directly to the remote machine.
 574    This does not inform the data cache; the data cache uses this.
 575    MEMADDR is the address in the remote memory space.
 576    MYADDR is the address of the buffer in our space.
 577    LEN is the number of bytes.  */
 578
 579 static void
 580 remote_write_bytes (memaddr, myaddr, len)
 581      CORE_ADDR memaddr;
 582      char *myaddr;
 583      int len;
 584 {
 585   char buf[PBUFSIZ];
 586   int i;
 587   char *p;
 588
 589   if (len > PBUFSIZ / 2 - 20)
 590     abort ();
 591
 592   sprintf (buf, "M%x,%x:", memaddr, len);
 593
 594   /* We send target system values byte by byte, in increasing byte addresses,
 595      each byte encoded as two hex characters.  */
 596
 597   p = buf + strlen (buf);
 598   for (i = 0; i < len; i++)
 599     {
 600       *p++ = tohex ((myaddr[i] >> 4) & 0xf);
 601       *p++ = tohex (myaddr[i] & 0xf);
 602     }
 603   *p = '\0';
 604
 605   remote_send (buf);
 606 }
 607
 608 /* Read memory data directly from the remote machine.
 609    This does not use the data cache; the data cache uses this.
 610    MEMADDR is the address in the remote memory space.
 611    MYADDR is the address of the buffer in our space.
 612    LEN is the number of bytes.  */
 613
 614 static void
 615 remote_read_bytes (memaddr, myaddr, len)
 616      CORE_ADDR memaddr;
 617      char *myaddr;
 618      int len;
 619 {
 620   char buf[PBUFSIZ];
 621   int i;
 622   char *p;
 623
 624   if (len > PBUFSIZ / 2 - 1)
 625     abort ();
 626
 627   sprintf (buf, "m%x,%x", memaddr, len);
 628   remote_send (buf);
 629
 630   /* Reply describes memory byte by byte,
 631      each byte encoded as two hex characters.  */
 632
 633   p = buf;
 634   for (i = 0; i < len; i++)
 635     {
 636       if (p[0] == 0 || p[1] == 0)
 637         error ("Remote reply is too short: %s", buf);
 638       myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
 639       p += 2;
 640     }
 641 }
 642 \f
 643 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
 644    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
 645    nonzero.  Returns length of data written or read; 0 for error.  */
 646
 647 /* ARGSUSED */
 648 static int
 649 remote_xfer_memory(memaddr, myaddr, len, should_write, target)
 650      CORE_ADDR memaddr;
 651      char *myaddr;
 652      int len;
 653      int should_write;
 654      struct target_ops *target;                 /* ignored */
 655 {
 656   int origlen = len;
 657   int xfersize;
 658   while (len > 0)
 659     {
 660       if (len > MAXBUFBYTES)
 661         xfersize = MAXBUFBYTES;
 662       else
 663         xfersize = len;
 664
 665       if (should_write)
 666         remote_write_bytes(memaddr, myaddr, xfersize);
 667       else
 668         remote_read_bytes (memaddr, myaddr, xfersize);
 669       memaddr += xfersize;
 670       myaddr  += xfersize;
 671       len     -= xfersize;
 672     }
 673   return origlen; /* no error possible */
 674 }
 675
 676 static void
 677 remote_files_info (ignore)
 678 struct target_ops *ignore;
 679 {
 680   printf ("Debugging a target over a serial line.\n");
 681 }
 682 \f
 683 /*
 684
 685 A debug packet whose contents are <data>
 686 is encapsulated for transmission in the form:
 687
 688         $ <data> # CSUM1 CSUM2
 689
 690         <data> must be ASCII alphanumeric and cannot include characters
 691         '$' or '#'
 692
 693         CSUM1 and CSUM2 are ascii hex representation of an 8-bit
 694         checksum of <data>, the most significant nibble is sent first.
 695         the hex digits 0-9,a-f are used.
 696
 697 Receiver responds with:
 698
 699         +       - if CSUM is correct and ready for next packet
 700         -       - if CSUM is incorrect
 701
 702 */
 703
 704 /* Read a single character from the remote end.
 705    (If supported, we actually read many characters and buffer them up.)  */
 706
 707 static int
 708 readchar ()
 709 {
 710   static int inbuf_index, inbuf_count;
 711 #define INBUFSIZE       PBUFSIZ
 712   static char inbuf[INBUFSIZE];
 713
 714   if (inbuf_index >= inbuf_count)
 715     {
 716       /* Time to do another read... */
 717       inbuf_index = 0;
 718       inbuf_count = 0;
 719       inbuf[0] = 0;             /* Just in case */
 720 #ifdef HAVE_TERMIO
 721       /* termio does the timeout for us.  */
 722       inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
 723 #else
 724       alarm (timeout);
 725       inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
 726       alarm (0);
 727 #endif
 728     }
 729
 730   /* Just return the next character from the buffer.  */
 731   return inbuf[inbuf_index++] & 0x7f;
 732 }
 733
 734 /* Send the command in BUF to the remote machine,
 735    and read the reply into BUF.
 736    Report an error if we get an error reply.  */
 737
 738 static void
 739 remote_send (buf)
 740      char *buf;
 741 {
 742
 743   putpkt (buf);
 744   getpkt (buf);
 745
 746   if (buf[0] == 'E')
 747     error ("Remote failure reply: %s", buf);
 748 }
 749
 750 /* Send a packet to the remote machine, with error checking.
 751    The data of the packet is in BUF.  */
 752
 753 static void
 754 putpkt (buf)
 755      char *buf;
 756 {
 757   int i;
 758   unsigned char csum = 0;
 759   char buf2[PBUFSIZ];
 760   int cnt = strlen (buf);
 761   char ch;
 762   char *p;
 763
 764   /* Copy the packet into buffer BUF2, encapsulating it
 765      and giving it a checksum.  */
 766
 767   if (cnt > sizeof(buf2) - 5)           /* Prosanity check */
 768     abort();
 769
 770   p = buf2;
 771   *p++ = '$';
 772
 773   for (i = 0; i < cnt; i++)
 774     {
 775       csum += buf[i];
 776       *p++ = buf[i];
 777     }
 778   *p++ = '#';
 779   *p++ = tohex ((csum >> 4) & 0xf);
 780   *p++ = tohex (csum & 0xf);
 781
 782   /* Send it over and over until we get a positive ack.  */
 783
 784   do {
 785     if (kiodebug)
 786       {
 787         *p = '\0';
 788         printf ("Sending packet: %s...", buf2);  fflush(stdout);
 789       }
 790     write (remote_desc, buf2, p - buf2);
 791
 792     /* read until either a timeout occurs (\0) or '+' is read */
 793     do {
 794       ch = readchar ();
 795       if (kiodebug) {
 796         if (ch == '+')
 797           printf("Ack\n");
 798         else
 799           printf ("%02X%c ", ch&0xFF, ch);
 800       }
 801     } while ((ch != '+') && (ch != '\0'));
 802   } while (ch != '+');
 803 }
 804
 805 /* Read a packet from the remote machine, with error checking,
 806    and store it in BUF.  BUF is expected to be of size PBUFSIZ.  */
 807
 808 static void
 809 getpkt (buf)
 810      char *buf;
 811 {
 812   char *bp;
 813   unsigned char csum;
 814   int c;
 815   unsigned char c1, c2;
 816   int retries = 0;
 817 #define MAX_RETRIES     10
 818
 819 #if 0
 820   /* Sorry, this will cause all hell to break loose, i.e. we'll end
 821      up in the command loop with an inferior, but (at least if this
 822      happens in remote_wait or some such place) without a current_frame,
 823      having set up prev_* in wait_for_inferior, etc.
 824
 825      If it is necessary to have such an "emergency exit", seems like
 826      the only plausible thing to do is to say the inferior died, and
 827      make the user reattach if they want to.  Perhaps with a prompt
 828      asking for confirmation.  */
 829
 830   /* allow immediate quit while reading from device, it could be hung */
 831   immediate_quit++;
 832 #endif /* 0 */
 833
 834   while (1)
 835     {
 836       /* Force csum to be zero here because of possible error retry.  */
 837       csum = 0;
 838
 839       while ((c = readchar()) != '$');
 840
 841       bp = buf;
 842       while (1)
 843         {
 844           c = readchar ();
 845           if (c == '#')
 846             break;
 847           if (bp >= buf+PBUFSIZ-1)
 848           {
 849             *bp = '\0';
 850             printf_filtered ("Remote packet too long: %s\n", buf);
 851             goto whole;
 852           }
 853           *bp++ = c;
 854           csum += c;
 855         }
 856       *bp = 0;
 857
 858       c1 = fromhex (readchar ());
 859       c2 = fromhex (readchar ());
 860       if ((csum & 0xff) == (c1 << 4) + c2)
 861         break;
 862       printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
 863               (c1 << 4) + c2, csum & 0xff, buf);
 864
 865       /* Try the whole thing again.  */
 866 whole:
 867       if (++retries < MAX_RETRIES)
 868         {
 869           write (remote_desc, "-", 1);
 870         }
 871       else
 872         {
 873           printf ("Ignoring packet error, continuing...\n");
 874           break;
 875         }
 876     }
 877
 878 #if 0
 879   immediate_quit--;
 880 #endif
 881
 882   write (remote_desc, "+", 1);
 883
 884   if (kiodebug)
 885     fprintf (stderr,"Packet received: %s\n", buf);
 886 }
 887 \f
 888 /* The data cache leads to incorrect results because it doesn't know about
 889    volatile variables, thus making it impossible to debug functions which
 890    use hardware registers.  Therefore it is #if 0'd out.  Effect on
 891    performance is some, for backtraces of functions with a few
 892    arguments each.  For functions with many arguments, the stack
 893    frames don't fit in the cache blocks, which makes the cache less
 894    helpful.  Disabling the cache is a big performance win for fetching
 895    large structures, because the cache code fetched data in 16-byte
 896    chunks.  */
 897 #if 0
 898 /* The data cache records all the data read from the remote machine
 899    since the last time it stopped.
 900
 901    Each cache block holds 16 bytes of data
 902    starting at a multiple-of-16 address.  */
 903
 904 #define DCACHE_SIZE 64          /* Number of cache blocks */
 905
 906 struct dcache_block {
 907         struct dcache_block *next, *last;
 908         unsigned int addr;      /* Address for which data is recorded.  */
 909         int data[4];
 910 };
 911
 912 struct dcache_block dcache_free, dcache_valid;
 913
 914 /* Free all the data cache blocks, thus discarding all cached data.  */
 915
 916 static void
 917 dcache_flush ()
 918 {
 919   register struct dcache_block *db;
 920
 921   while ((db = dcache_valid.next) != &dcache_valid)
 922     {
 923       remque (db);
 924       insque (db, &dcache_free);
 925     }
 926 }
 927
 928 /*
 929  * If addr is present in the dcache, return the address of the block
 930  * containing it.
 931  */
 932
 933 struct dcache_block *
 934 dcache_hit (addr)
 935 {
 936   register struct dcache_block *db;
 937
 938   if (addr & 3)
 939     abort ();
 940
 941   /* Search all cache blocks for one that is at this address.  */
 942   db = dcache_valid.next;
 943   while (db != &dcache_valid)
 944     {
 945       if ((addr & 0xfffffff0) == db->addr)
 946         return db;
 947       db = db->next;
 948     }
 949   return NULL;
 950 }
 951
 952 /*  Return the int data at address ADDR in dcache block DC.  */
 953
 954 int
 955 dcache_value (db, addr)
 956      struct dcache_block *db;
 957      unsigned int addr;
 958 {
 959   if (addr & 3)
 960     abort ();
 961   return (db->data[(addr>>2)&3]);
 962 }
 963
 964 /* Get a free cache block, put it on the valid list,
 965    and return its address.  The caller should store into the block
 966    the address and data that it describes.  */
 967
 968 struct dcache_block *
 969 dcache_alloc ()
 970 {
 971   register struct dcache_block *db;
 972
 973   if ((db = dcache_free.next) == &dcache_free)
 974     /* If we can't get one from the free list, take last valid */
 975     db = dcache_valid.last;
 976
 977   remque (db);
 978   insque (db, &dcache_valid);
 979   return (db);
 980 }
 981
 982 /* Return the contents of the word at address ADDR in the remote machine,
 983    using the data cache.  */
 984
 985 int
 986 dcache_fetch (addr)
 987      CORE_ADDR addr;
 988 {
 989   register struct dcache_block *db;
 990
 991   db = dcache_hit (addr);
 992   if (db == 0)
 993     {
 994       db = dcache_alloc ();
 995       remote_read_bytes (addr & ~0xf, db->data, 16);
 996       db->addr = addr & ~0xf;
 997     }
 998   return (dcache_value (db, addr));
 999 }
1000
1001 /* Write the word at ADDR both in the data cache and in the remote machine.  */
1002
1003 dcache_poke (addr, data)
1004      CORE_ADDR addr;
1005      int data;
1006 {
1007   register struct dcache_block *db;
1008
1009   /* First make sure the word is IN the cache.  DB is its cache block.  */
1010   db = dcache_hit (addr);
1011   if (db == 0)
1012     {
1013       db = dcache_alloc ();
1014       remote_read_bytes (addr & ~0xf, db->data, 16);
1015       db->addr = addr & ~0xf;
1016     }
1017
1018   /* Modify the word in the cache.  */
1019   db->data[(addr>>2)&3] = data;
1020
1021   /* Send the changed word.  */
1022   remote_write_bytes (addr, &data, 4);
1023 }
1024
1025 /* Initialize the data cache.  */
1026
1027 dcache_init ()
1028 {
1029   register i;
1030   register struct dcache_block *db;
1031
1032   db = (struct dcache_block *) xmalloc (sizeof (struct dcache_block) *
1033                                         DCACHE_SIZE);
1034   dcache_free.next = dcache_free.last = &dcache_free;
1035   dcache_valid.next = dcache_valid.last = &dcache_valid;
1036   for (i=0;i<DCACHE_SIZE;i++,db++)
1037     insque (db, &dcache_free);
1038 }
1039 #endif /* 0 */
1040
1041 /* Define the target subroutine names */
1042
1043 struct target_ops remote_ops = {
1044   "remote",                     /* to_shortname */
1045   "Remote serial target in gdb-specific protocol",      /* to_longname */
1046   "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1047 Specify the serial device it is connected to (e.g. /dev/ttya).",  /* to_doc */
1048   remote_open,                  /* to_open */
1049   remote_close,                 /* to_close */
1050   NULL,                         /* to_attach */
1051   remote_detach,                /* to_detach */
1052   remote_resume,                /* to_resume */
1053   remote_wait,                  /* to_wait */
1054   remote_fetch_registers,       /* to_fetch_registers */
1055   remote_store_registers,       /* to_store_registers */
1056   remote_prepare_to_store,      /* to_prepare_to_store */
1057   remote_xfer_memory,           /* to_xfer_memory */
1058   remote_files_info,            /* to_files_info */
1059   NULL,                         /* to_insert_breakpoint */
1060   NULL,                         /* to_remove_breakpoint */
1061   NULL,                         /* to_terminal_init */
1062   NULL,                         /* to_terminal_inferior */
1063   NULL,                         /* to_terminal_ours_for_output */
1064   NULL,                         /* to_terminal_ours */
1065   NULL,                         /* to_terminal_info */
1066   NULL,                         /* to_kill */
1067   NULL,                         /* to_load */
1068   NULL,                         /* to_lookup_symbol */
1069   NULL,                         /* to_create_inferior */
1070   NULL,                         /* to_mourn_inferior */
1071   process_stratum,              /* to_stratum */
1072   NULL,                         /* to_next */
1073   1,                            /* to_has_all_memory */
1074   1,                            /* to_has_memory */
1075   1,                            /* to_has_stack */
1076   1,                            /* to_has_registers */
1077   1,                            /* to_has_execution */
1078   NULL,                         /* sections */
1079   NULL,                         /* sections_end */
1080   OPS_MAGIC                     /* to_magic */
1081 };
1082
1083 void
1084 _initialize_remote ()
1085 {
1086   add_target (&remote_ops);
1087
1088   add_show_from_set (
1089     add_set_cmd ("remotedebug", no_class, var_boolean, (char *)&kiodebug,
1090                    "Set debugging of remote serial I/O.\n\
1091 When enabled, each packet sent or received with the remote target\n\
1092 is displayed.", &setlist),
1093         &showlist);
1094 }
1095
1096 #endif