gdb/remote-rdp.c

   1 /* Remote debugging for the ARM RDP interface.
   2    Copyright 1994, 1995 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20
  21  */
  22
  23
  24 /*
  25    Much of this file (in particular the SWI stuff) is based on code by
  26    David Taylor ([email protected]).
  27
  28    I hacked on and simplified it by removing a lot of sexy features he
  29    had added, and some of the (unix specific) workarounds he'd done
  30    for other GDB problems - which if they still exist should be fixed
  31    in GDB, not in a remote-foo thing .  I also made it conform more to
  32    the doc I have; which may be wrong.
  33
  34    Steve Chamberlain ([email protected]).
  35  */
  36
  37
  38 #include "defs.h"
  39 #include "inferior.h"
  40 #include "wait.h"
  41 #include "value.h"
  42 #include "callback.h"
  43 #include "command.h"
  44 #ifdef ANSI_PROTOTYPES
  45 #include <stdarg.h>
  46 #else
  47 #include <varargs.h>
  48 #endif
  49
  50 #include <fcntl.h>
  51 #include "symfile.h"
  52 #include "remote-utils.h"
  53
  54 extern struct target_ops remote_rdp_ops;
  55 static serial_t io;
  56 static host_callback *callback = &default_callback;
  57
  58 struct
  59 {
  60   int step_info;
  61   int break_info;
  62   int model_info;
  63   int target_info;
  64   int can_step;
  65   char command_line[10];
  66   int rdi_level;
  67   int rdi_stopped_status;
  68 } ds;
  69
  70
  71
  72 /* Definitions for the RDP protocol. */
  73
  74 #define RDP_MOUTHFULL                   (1<<6)
  75 #define FPU_COPRO_NUMBER                1
  76
  77 #define RDP_OPEN                        0
  78 #define RDP_OPEN_TYPE_COLD              0
  79 #define RDP_OPEN_TYPE_WARM              1
  80 #define RDP_OPEN_TYPE_BAUDRATE          2
  81
  82 #define RDP_OPEN_BAUDRATE_9600          1
  83 #define RDP_OPEN_BAUDRATE_19200         2
  84 #define RDP_OPEN_BAUDRATE_38400         3
  85
  86 #define RDP_OPEN_TYPE_RETURN_SEX        (1<<3)
  87
  88 #define RDP_CLOSE                       1
  89
  90 #define RDP_MEM_READ                    2
  91
  92 #define RDP_MEM_WRITE                   3
  93
  94 #define RDP_CPU_READ                    4
  95 #define RDP_CPU_WRITE                   5
  96 #define RDP_CPU_READWRITE_MODE_CURRENT 255
  97 #define RDP_CPU_READWRITE_MASK_PC       (1<<16)
  98 #define RDP_CPU_READWRITE_MASK_CPSR     (1<<17)
  99 #define RDP_CPU_READWRITE_MASK_SPSR     (1<<18)
 100
 101 #define RDP_COPRO_READ                  6
 102 #define RDP_COPRO_WRITE                 7
 103 #define RDP_FPU_READWRITE_MASK_FPS      (1<<8)
 104
 105 #define RDP_SET_BREAK                   0xa
 106 #define RDP_SET_BREAK_TYPE_PC_EQUAL     0
 107 #define RDP_SET_BREAK_TYPE_GET_HANDLE   (0x10)
 108
 109 #define RDP_CLEAR_BREAK                 0xb
 110
 111 #define RDP_EXEC                        0x10
 112 #define RDP_EXEC_TYPE_SYNC              0
 113
 114 #define RDP_STEP                        0x11
 115
 116 #define RDP_INFO                        0x12
 117 #define RDP_INFO_ABOUT_STEP             2
 118 #define RDP_INFO_ABOUT_STEP_GT_1        1
 119 #define RDP_INFO_ABOUT_STEP_TO_JMP      2
 120 #define RDP_INFO_ABOUT_STEP_1           4
 121 #define RDP_INFO_ABOUT_TARGET           0
 122 #define RDP_INFO_ABOUT_BREAK            1
 123 #define RDP_INFO_ABOUT_BREAK_COMP       1
 124 #define RDP_INFO_ABOUT_BREAK_RANGE      2
 125 #define RDP_INFO_ABOUT_BREAK_BYTE_READ  4
 126 #define RDP_INFO_ABOUT_BREAK_HALFWORD_READ 8
 127 #define RDP_INFO_ABOUT_BREAK_WORD_READ (1<<4)
 128 #define RDP_INFO_ABOUT_BREAK_BYTE_WRITE (1<<5)
 129 #define RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE (1<<6)
 130 #define RDP_INFO_ABOUT_BREAK_WORD_WRITE (1<<7)
 131 #define RDP_INFO_ABOUT_BREAK_MASK       (1<<8)
 132 #define RDP_INFO_ABOUT_BREAK_THREAD_BREAK (1<<9)
 133 #define RDP_INFO_ABOUT_BREAK_THREAD_WATCH (1<<10)
 134 #define RDP_INFO_ABOUT_BREAK_COND       (1<<11)
 135
 136 #define RDP_RESET                       0x7f
 137
 138 /* Returns from RDP */
 139 #define RDP_RES_STOPPED                 0x20
 140 #define RDP_RES_SWI                     0x21
 141 #define RDP_RES_FATAL                   0x5e
 142 #define RDP_RES_VALUE                   0x5f
 143 #define RDP_RES_VALUE_LITTLE_ENDIAN     240
 144 #define RDP_RES_VALUE_BIG_ENDIAN        241
 145 #define RDP_RES_RESET                   0x7f
 146 #define RDP_RES_AT_BREAKPOINT           143
 147 #define RDP_RES_IDUNNO                  0xe6
 148 #define RDP_OSOpReply                   0x13
 149 #define RDP_OSOpWord                    2
 150 #define RDP_OSOpNothing                 0
 151
 152 static int timeout = 2;
 153
 154 static int
 155 remote_rdp_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
 156                                      char *myaddr,
 157                                      int len,
 158                                      int write,
 159                                      struct target_ops * target));
 160
 161
 162 /* Stuff for talking to the serial layer. */
 163
 164 static unsigned char
 165 get_byte ()
 166 {
 167   int c = SERIAL_READCHAR (io, timeout);
 168
 169   if (remote_debug)
 170     printf ("[%02x]", c);
 171
 172   if (c == SERIAL_TIMEOUT)
 173     {
 174       if (timeout == 0)
 175         return (unsigned char) c;
 176
 177       error ("Timeout reading from remote_system");
 178     }
 179
 180   return c;
 181 }
 182
 183 /* Note that the target always speaks little-endian to us,
 184    even if it's a big endian machine. */
 185 static unsigned int
 186 get_word ()
 187 {
 188   unsigned int val = 0;
 189   unsigned int c;
 190   int n;
 191   for (n = 0; n < 4; n++)
 192     {
 193       c = get_byte ();
 194       val |= c << (n * 8);
 195     }
 196   return val;
 197 }
 198
 199 static void
 200 put_byte (val)
 201      char val;
 202 {
 203   if (remote_debug)
 204     printf("(%02x)", val);
 205   SERIAL_WRITE (io, &val, 1);
 206 }
 207
 208 static void
 209 put_word (val)
 210      long val;
 211 {
 212   /* We always send in little endian */
 213   unsigned char b[4];
 214   b[0] = val;
 215   b[1] = val >> 8;
 216   b[2] = val >> 16;
 217   b[3] = val >> 24;
 218
 219   if (remote_debug)
 220     printf("(%04x)", val);
 221
 222   SERIAL_WRITE (io, b, 4);
 223 }
 224
 225
 226
 227 /* Stuff for talking to the RDP layer. */
 228
 229 /* This is a bit more fancy that need be so that it syncs even in nasty cases. */
 230
 231 static void
 232 rdp_init (int cold)
 233 {
 234   int oloop;
 235   int sync = 0;
 236   int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM;
 237   int try;
 238   int rcount = 0;
 239   int bi;
 240
 241   for (try = 0; !sync && try < 10 ; try++)
 242     {
 243       int restype;
 244       QUIT;
 245       SERIAL_FLUSH_INPUT (io);
 246       put_byte (RDP_OPEN);
 247
 248       if (baud_rate == 19200)
 249         {
 250           put_byte (type | RDP_OPEN_TYPE_RETURN_SEX | RDP_OPEN_TYPE_BAUDRATE);
 251           put_word (0);
 252           put_word (RDP_OPEN_BAUDRATE_19200);
 253         }
 254       else
 255         {
 256           put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
 257           put_word (0);
 258         }
 259
 260       restype = SERIAL_READCHAR (io, 1);
 261
 262       if (remote_debug)
 263         printf_unfiltered ("[%02x]\n", restype);
 264
 265       if (restype == RDP_RESET)
 266         {
 267           put_byte (RDP_RESET);
 268           while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
 269             ;
 270           while ((restype = SERIAL_READCHAR (io, 1)) > 0)
 271             {
 272               printf_unfiltered ("%c", isgraph(restype) ? restype : ' ');
 273             }
 274           while ((restype = SERIAL_READCHAR (io, 1)) > 0)
 275             ;
 276           printf_unfiltered("\n");
 277           error("board reset, try again.\n");
 278           continue;
 279         }
 280
 281       switch (restype)
 282         {
 283         case SERIAL_TIMEOUT:
 284           break;
 285         case RDP_RESET:
 286           /* Ignore a load of these */
 287           break;
 288         default:
 289           break;
 290         case RDP_RES_VALUE:
 291           {
 292             int resval = SERIAL_READCHAR (io, 1);
 293             switch (resval)
 294               {
 295               case SERIAL_TIMEOUT:
 296                 break;
 297               case RDP_RES_VALUE_LITTLE_ENDIAN:
 298                 target_byte_order = LITTLE_ENDIAN;
 299                 sync =1 ;
 300                 break;
 301               case RDP_RES_VALUE_BIG_ENDIAN:
 302                 target_byte_order = BIG_ENDIAN;
 303                 sync =1 ;
 304                 break;
 305               default:
 306                 break;
 307               }
 308           }
 309         }
 310     }
 311
 312   if (sync)
 313     {
 314       SERIAL_FLUSH_INPUT (io);
 315       SERIAL_SETBAUDRATE (io, baud_rate);
 316       SERIAL_FLUSH_INPUT (io);
 317     }
 318   else
 319     {
 320       error ("Couldn't reset the board, try pressing the reset button");
 321     }
 322 }
 323
 324
 325 #ifdef ANSI_PROTOTYPES
 326 void
 327 send_rdp (char *template,...)
 328 #else
 329 void
 330 send_rdp (char *template, va_alist)
 331      va_dcl
 332 #endif
 333 {
 334   char buf[200];
 335   char *dst = buf;
 336   va_list alist;
 337 #ifdef ANSI_PROTOTYPES
 338   va_start (alist, template);
 339 #else
 340   va_start (alist);
 341 #endif
 342
 343   while (*template)
 344     {
 345       unsigned int val;
 346       int *pi;
 347       int *pstat;
 348       char *pc;
 349       int i;
 350       switch (*template++)
 351         {
 352         case 'b':
 353           val = va_arg (alist, int);
 354           *dst++ = val;
 355           break;
 356         case 'w':
 357           val = va_arg (alist, int);
 358           *dst++ = val;
 359           *dst++ = val >> 8;
 360           *dst++ = val >> 16;
 361           *dst++ = val >> 24;
 362           break;
 363         case 'S':
 364           val = get_byte ();
 365           if (val != RDP_RES_VALUE)
 366             {
 367               printf_unfiltered ("got bad res value of %d, %x\n", val, val);
 368             }
 369           break;
 370         case 'V':
 371           pstat = va_arg (alist, int *);
 372           pi = va_arg (alist, int *);
 373
 374           *pstat = get_byte ();
 375           /* Check the result was zero, if not read the syndrome */
 376           if (*pstat)
 377             {
 378               *pi = get_word ();
 379             }
 380           break;
 381         case 'Z':
 382           /* Check the result code, error if not zero */
 383           if (get_byte ())
 384             error ("Command garbled");
 385           break;
 386         case 'W':
 387           /* Read a word from the target */
 388           pi = va_arg (alist, int *);
 389           *pi = get_word ();
 390           break;
 391         case 'P':
 392           /* Read in some bytes from the target. */
 393           pc = va_arg (alist, char *);
 394           val = va_arg (alist, int);
 395           for (i = 0; i < val; i++)
 396             {
 397               pc[i] = get_byte ();
 398             }
 399           break;
 400         case 'p':
 401           /* send what's being pointed at */
 402           pc = va_arg (alist, char *);
 403           val = va_arg (alist, int);
 404           dst = buf;
 405           SERIAL_WRITE (io, pc, val);
 406           break;
 407         case '-':
 408           /* Send whats in the queue */
 409           if (dst != buf)
 410             {
 411               SERIAL_WRITE (io, buf, dst - buf);
 412               dst = buf;
 413             }
 414           break;
 415         case 'B':
 416           pi = va_arg (alist, int *);
 417           *pi = get_byte ();
 418           break;
 419         default:
 420           abort ();
 421         }
 422     }
 423   va_end (args);
 424
 425   if (dst != buf)
 426     abort ();
 427 }
 428
 429
 430 static int
 431 rdp_write (memaddr, buf, len)
 432      CORE_ADDR memaddr;
 433      char *buf;
 434      int len;
 435 {
 436   int res;
 437   int val;
 438
 439   send_rdp ("bww-p-SV", RDP_MEM_WRITE, memaddr, len, buf, len, &res, &val);
 440
 441   if (res)
 442     {
 443       return val;
 444     }
 445   return len;
 446 }
 447
 448
 449 static int
 450 rdp_read (memaddr, buf, len)
 451      CORE_ADDR memaddr;
 452      char *buf;
 453      int len;
 454 {
 455   int res;
 456   int val;
 457   send_rdp ("bww-S-P-V",
 458             RDP_MEM_READ, memaddr, len,
 459             buf, len,
 460             &res, &val);
 461   if (res)
 462     {
 463       return val;
 464     }
 465   return len;
 466 }
 467
 468 static void
 469 rdp_fetch_one_register (mask, buf)
 470      int mask;
 471      char *buf;
 472 {
 473   int val;
 474   send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
 475   store_signed_integer (buf, 4, val);
 476 }
 477
 478 static void
 479 rdp_fetch_one_fpu_register (mask, buf)
 480      int mask;
 481      char *buf;
 482 {
 483 #if 0
 484   /* !!! Since the PIE board doesn't work as documented,
 485      and it doesn't have FPU hardware anyway and since it
 486      slows everything down, I've disabled this. */
 487   int val;
 488   if (mask == RDP_FPU_READWRITE_MASK_FPS)
 489     {
 490       /* this guy is only a word */
 491       send_rdp ("bbw-SWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, &val);
 492       store_signed_integer (buf, 4, val);
 493     }
 494   else
 495     {
 496       /* There are 12 bytes long
 497          !! fixme about endianness
 498          */
 499       int dummy;                /* I've seen these come back as four words !! */
 500       send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
 501     }
 502 #endif
 503   memset (buf, 0, MAX_REGISTER_RAW_SIZE);
 504 }
 505
 506
 507 static void
 508 rdp_store_one_register (mask, buf)
 509      int mask;
 510      char *buf;
 511 {
 512   int val = extract_unsigned_integer (buf, 4);
 513
 514   send_rdp ("bbww-SZ",
 515             RDP_CPU_WRITE, RDP_CPU_READWRITE_MODE_CURRENT, mask, val);
 516 }
 517
 518
 519 static void
 520 rdp_store_one_fpu_register (mask, buf)
 521      int mask;
 522      char *buf;
 523 {
 524 #if 0
 525   /* See comment in fetch_one_fpu_register */
 526   if (mask == RDP_FPU_READWRITE_MASK_FPS)
 527     {
 528       int val = extract_unsigned_integer (buf, 4);
 529       /* this guy is only a word */
 530       send_rdp ("bbww-SZ", RDP_COPRO_WRITE,
 531                 FPU_COPRO_NUMBER,
 532                 mask, val);
 533     }
 534   else
 535     {
 536       /* There are 12 bytes long
 537          !! fixme about endianness
 538        */
 539       int dummy = 0;
 540       /* I've seen these come as four words, not the three advertized !! */
 541       printf ("Sending mask %x\n", mask);
 542       send_rdp ("bbwwwww-SZ",
 543                 RDP_COPRO_WRITE,
 544                 FPU_COPRO_NUMBER,
 545                 mask,
 546                 *(int *) (buf + 0),
 547                 *(int *) (buf + 4),
 548                 *(int *) (buf + 8),
 549                 0);
 550
 551       printf ("done mask %x\n", mask);
 552     }
 553 #endif
 554 }
 555
 556 \f
 557 /* Convert between GDB requests and the RDP layer. */
 558
 559 static void
 560 remote_rdp_fetch_register (regno)
 561      int regno;
 562 {
 563   if (regno == -1)
 564     {
 565       for (regno = 0; regno < NUM_REGS; regno++)
 566         remote_rdp_fetch_register (regno);
 567     }
 568   else
 569     {
 570       char buf[MAX_REGISTER_RAW_SIZE];
 571       if (regno < 15)
 572         rdp_fetch_one_register (1 << regno, buf);
 573       else if (regno == PC_REGNUM)
 574         rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
 575       else if (regno == PS_REGNUM)
 576         rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
 577       else if (regno == FPS_REGNUM)
 578         rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
 579       else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
 580         rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
 581       else
 582         {
 583           printf ("Help me with fetch reg %d\n", regno);
 584         }
 585       supply_register (regno, buf);
 586     }
 587 }
 588
 589
 590 static void
 591 remote_rdp_store_register (regno)
 592      int regno;
 593 {
 594   if (regno == -1)
 595     {
 596       for (regno = 0; regno < NUM_REGS; regno++)
 597         remote_rdp_store_register (regno);
 598     }
 599   else
 600     {
 601       char tmp[MAX_REGISTER_RAW_SIZE];
 602       read_register_gen (regno, tmp);
 603       if (regno < 15)
 604         rdp_store_one_register (1 << regno, tmp);
 605       else if (regno == PC_REGNUM)
 606         rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
 607       else if (regno == PS_REGNUM)
 608         rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
 609       else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
 610         rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
 611       else
 612         {
 613           printf ("Help me with reg %d\n", regno);
 614         }
 615     }
 616 }
 617
 618 static void
 619 remote_rdp_kill ()
 620 {
 621   callback->shutdown (callback);
 622 }
 623
 624
 625 static void
 626 rdp_info ()
 627 {
 628   send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
 629             &ds.step_info);
 630   send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_BREAK,
 631             &ds.break_info);
 632   send_rdp ("bw-S-WW-Z", RDP_INFO, RDP_INFO_ABOUT_TARGET,
 633             &ds.target_info,
 634             &ds.model_info);
 635
 636   ds.can_step = ds.step_info & RDP_INFO_ABOUT_STEP_1;
 637
 638   ds.rdi_level = (ds.target_info >> 5) & 3;
 639 }
 640
 641
 642 static void
 643 rdp_execute_start ()
 644 {
 645   /* Start it off, but don't wait for it */
 646   send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
 647 }
 648
 649
 650
 651 #define a_byte 1
 652 #define a_word 2
 653 #define a_string 3
 654
 655
 656 typedef struct
 657 {
 658   CORE_ADDR n;
 659   const char *s;
 660 }
 661 argsin;
 662
 663 #define ABYTE 1
 664 #define AWORD 2
 665 #define ASTRING 3
 666 #define ADDRLEN 4
 667
 668 #define SWI_WriteC                      0x0
 669 #define SWI_Write0                      0x2
 670 #define SWI_ReadC                       0x4
 671 #define SWI_CLI                         0x5
 672 #define SWI_GetEnv                      0x10
 673 #define SWI_Exit                        0x11
 674 #define SWI_EnterOS                     0x16
 675
 676 #define SWI_GetErrno                    0x60
 677 #define SWI_Clock                       0x61
 678
 679 #define SWI_Time                        0x63
 680 #define SWI_Remove                      0x64
 681 #define SWI_Rename                      0x65
 682 #define SWI_Open                        0x66
 683
 684 #define SWI_Close                       0x68
 685 #define SWI_Write                       0x69
 686 #define SWI_Read                        0x6a
 687 #define SWI_Seek                        0x6b
 688 #define SWI_Flen                        0x6c
 689
 690 #define SWI_IsTTY                       0x6e
 691 #define SWI_TmpNam                      0x6f
 692 #define SWI_InstallHandler              0x70
 693 #define SWI_GenerateError               0x71
 694
 695
 696 static int
 697 exec_swi (swi, args)
 698      int swi;
 699      argsin *args;
 700 {
 701   int i;
 702   char c;
 703   switch (swi)
 704     {
 705     case SWI_WriteC:
 706       callback->write_stdout (callback, &c, 1);
 707       return 0;
 708     case SWI_Write0:
 709       for (i = 0; i < args->n; i++)
 710         callback->write_stdout (callback, args->s, strlen (args->s));
 711       return 0;
 712     case SWI_ReadC:
 713       callback->read_stdin (callback, &c, 1);
 714       args->n = c;
 715       return 1;
 716     case SWI_CLI:
 717       args->n = callback->system (callback, args->s);
 718       return 1;
 719     case SWI_GetErrno:
 720       args->n = callback->get_errno (callback);
 721       return 1;
 722     case SWI_Time:
 723       args->n = callback->time (callback, NULL);
 724       return 1;
 725     case SWI_Remove:
 726       args->n = callback->unlink (callback, args->s);
 727       return 1;
 728     case SWI_Rename:
 729       args->n = callback->rename (callback, args[0].s, args[1].s);
 730       return 1;
 731     case SWI_Open:
 732       i = 0;
 733
 734 #ifdef O_BINARY
 735       if (args[1].n & 1)
 736         i |= O_BINARY;
 737 #endif
 738       if (args[1].n & 2)
 739         i |= O_RDWR;
 740
 741       if (args[1].n & 4)
 742         {
 743           i |= O_CREAT;
 744         }
 745
 746       if (args[1].n & 8)
 747         i |= O_APPEND;
 748
 749       args->n = callback->open (callback, args->s, i);
 750       return 1;
 751
 752     case SWI_Close:
 753       args->n = callback->close (callback, args->n);
 754       return 1;
 755
 756     case SWI_Write:
 757       args->n = callback->write (callback, args[0].n, args[1].s, args[1].n);
 758       return 1;
 759     case SWI_Read:
 760       {
 761         char *copy = alloca (args[2].n);
 762         int done = callback->read (callback, args[0].n, copy, args[2].n);
 763         if (done > 0)
 764           remote_rdp_xfer_inferior_memory (args[0].n, copy, done, 1, 0);
 765         args->n -= done;
 766         return 1;
 767       }
 768
 769     case SWI_Seek:
 770       args->n = callback->lseek (callback, args[0].n, args[1].n, 0) >= 0;
 771       return 1;
 772     case SWI_Flen:
 773       {
 774         long old = callback->lseek (callback, args->n, 1, 1);
 775         args->n = callback->lseek (callback, args->n, 2, 0);
 776         callback->lseek (callback, args->n, old, 0);
 777         return 1;
 778       }
 779
 780     case SWI_IsTTY:
 781       args->n = callback->isatty (callback, args->n);
 782       return 1;
 783
 784     default:
 785       return 0;
 786     }
 787 }
 788
 789
 790 static void
 791 handle_swi ()
 792 {
 793   argsin args[3];
 794   char *buf;
 795   int len;
 796   int count = 0;
 797
 798   int swino = get_word ();
 799   int type = get_byte ();
 800   while (type != 0)
 801     {
 802       switch (type & 0x3)
 803         {
 804         case ABYTE:
 805           args[count].n = get_byte ();
 806           break;
 807
 808         case AWORD:
 809           args[count].n = get_word ();
 810           break;
 811
 812         case ASTRING:
 813           /* If the word is under 32 bytes it will be sent otherwise
 814              an address to it is passed. Also: Special case of 255 */
 815
 816           len = get_byte ();
 817           if (len > 32)
 818             {
 819               if (len == 255)
 820                 {
 821                   len = get_word ();
 822                 }
 823               buf = alloca (len);
 824               remote_rdp_xfer_inferior_memory (get_word (),
 825                                                buf,
 826                                                len,
 827                                                0,
 828                                                0);
 829             }
 830           else
 831             {
 832               int i;
 833               buf = alloca (len + 1);
 834               for (i = 0; i < len; i++)
 835                 buf[i] = get_byte ();
 836               buf[i] = 0;
 837             }
 838           args[count].n = len;
 839           args[count].s = buf;
 840           break;
 841
 842         default:
 843           error ("Unimplented SWI argument");
 844         }
 845
 846       type = type >> 2;
 847       count++;
 848     }
 849
 850   if (exec_swi (swino, args))
 851     {
 852       /* We have two options here reply with either a byte or a word
 853          which is stored in args[0].n. There is no harm in replying with
 854          a word all the time, so thats what I do! */
 855       send_rdp ("bbw-", RDP_OSOpReply, RDP_OSOpWord, args[0].n);
 856     }
 857   else
 858     {
 859       send_rdp ("bb-", RDP_OSOpReply, RDP_OSOpNothing);
 860     }
 861 }
 862
 863 static void
 864 rdp_execute_finish ()
 865 {
 866   int running = 1;
 867
 868   while (running)
 869     {
 870       int res;
 871       res = SERIAL_READCHAR (io, 1);
 872       while (res == SERIAL_TIMEOUT)
 873         {
 874           QUIT ;
 875           printf_filtered ("Waiting for target..\n");
 876           res = SERIAL_READCHAR (io, 1);
 877         }
 878
 879       switch (res)
 880         {
 881         case RDP_RES_SWI:
 882           handle_swi ();
 883           break;
 884         case RDP_RES_VALUE:
 885           send_rdp ("B", &ds.rdi_stopped_status);
 886           running = 0;
 887           break;
 888         case RDP_RESET:
 889           printf_filtered ("Target reset\n");
 890           running = 0;
 891           break;
 892         default:
 893           printf_filtered ("Ignoring %x\n", res);
 894           break;
 895         }
 896     }
 897 }
 898
 899
 900 static void
 901 rdp_execute ()
 902 {
 903   rdp_execute_start ();
 904   rdp_execute_finish ();
 905 }
 906
 907 static int
 908 remote_rdp_insert_breakpoint (addr, save)
 909      CORE_ADDR addr;
 910      char *save;
 911 {
 912   int res;
 913   if (ds.rdi_level > 0)
 914     {
 915       send_rdp ("bwb-SWB",
 916                 RDP_SET_BREAK,
 917                 addr,
 918                 RDP_SET_BREAK_TYPE_PC_EQUAL | RDP_SET_BREAK_TYPE_GET_HANDLE,
 919                 save,
 920                 &res);
 921     }
 922   else
 923     {
 924       send_rdp ("bwb-SB",
 925                 RDP_SET_BREAK,
 926                 addr,
 927                 RDP_SET_BREAK_TYPE_PC_EQUAL,
 928                 &res);
 929     }
 930   return res;
 931 }
 932
 933 static int
 934 remote_rdp_remove_breakpoint (addr, save)
 935      CORE_ADDR addr;
 936      char *save;
 937 {
 938   int res;
 939   if (ds.rdi_level > 0)
 940     {
 941       send_rdp ("b-p-S-B",
 942                 RDP_CLEAR_BREAK,
 943                 save, 4,
 944                 &res);
 945     }
 946   else
 947     {
 948       send_rdp ("bw-S-B",
 949                 RDP_CLEAR_BREAK,
 950                 addr,
 951                 &res);
 952     }
 953   return res;
 954 }
 955
 956 static void
 957 rdp_step ()
 958 {
 959   if (ds.can_step && 0)
 960     {
 961       /* The pie board can't do steps so I can't test this, and
 962          the other code will always work. */
 963       int status;
 964       send_rdp ("bbw-S-B",
 965                 RDP_STEP, 0, 1,
 966                 &status);
 967     }
 968   else
 969     {
 970       char handle[4];
 971       CORE_ADDR pc = read_register (PC_REGNUM);
 972       pc = arm_get_next_pc (pc);
 973       remote_rdp_insert_breakpoint (pc, &handle);
 974       rdp_execute ();
 975       remote_rdp_remove_breakpoint (pc, &handle);
 976     }
 977 }
 978
 979 static void
 980 remote_rdp_open (args, from_tty)
 981      char *args;
 982      int from_tty;
 983 {
 984   if (!args)
 985     error_no_arg ("serial port device name");
 986
 987   if (baud_rate != 19200)
 988     baud_rate = 9600;
 989
 990   target_preopen (from_tty);
 991
 992   io = SERIAL_OPEN (args);
 993
 994   if (!io)
 995     perror_with_name (args);
 996
 997   SERIAL_RAW (io);
 998
 999   rdp_init (0);
1000
1001
1002   if (from_tty)
1003     {
1004       printf_unfiltered ("Remote RDP debugging using %s at %d baud\n", args, baud_rate);
1005     }
1006
1007   rdp_info ();
1008
1009   push_target (&remote_rdp_ops);
1010
1011   callback->init (callback);
1012   flush_cached_frames ();
1013   registers_changed ();
1014   stop_pc = read_pc ();
1015   set_current_frame (create_new_frame (read_fp (), stop_pc));
1016   select_frame (get_current_frame (), 0);
1017   print_stack_frame (selected_frame, -1, 1);
1018 }
1019
1020
1021
1022 /* Close out all files and local state before this target loses control. */
1023
1024 static void
1025 remote_rdp_close (quitting)
1026      int quitting;
1027 {
1028   callback->shutdown (callback);
1029   if (io)
1030     SERIAL_CLOSE (io);
1031   io = 0;
1032 }
1033
1034 /* Terminate the open connection to the remote debugger. */
1035
1036 static void
1037 remote_rdp_detach (args, from_tty)
1038      char *args;
1039      int from_tty;
1040 {
1041   pop_target ();
1042 }
1043
1044 /* Resume execution of the target process.  STEP says whether to single-step
1045    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
1046    to the target, or zero for no signal.  */
1047
1048 static void
1049 remote_rdp_resume (pid, step, siggnal)
1050      int pid, step;
1051      enum target_signal siggnal;
1052 {
1053   if (step)
1054     rdp_step ();
1055   else
1056     rdp_execute ();
1057 }
1058
1059 /* Wait for inferior process to do something.  Return pid of child,
1060    or -1 in case of error; store status through argument pointer STATUS,
1061    just as `wait' would.  */
1062
1063 static int
1064 remote_rdp_wait (pid, status)
1065      int pid;
1066      struct target_waitstatus *status;
1067 {
1068   switch (ds.rdi_stopped_status)
1069     {
1070     default:
1071     case RDP_RES_RESET:
1072     case RDP_RES_SWI:
1073       status->kind = TARGET_WAITKIND_EXITED;
1074       status->value.integer = read_register (0);
1075       break;
1076     case RDP_RES_AT_BREAKPOINT:
1077       status->kind = TARGET_WAITKIND_STOPPED;
1078       /* The signal in sigrc is a host signal.  That probably
1079          should be fixed.  */
1080       status->value.sig = TARGET_SIGNAL_TRAP;
1081       break;
1082 #if 0
1083     case rdp_signalled:
1084       status->kind = TARGET_WAITKIND_SIGNALLED;
1085       /* The signal in sigrc is a host signal.  That probably
1086          should be fixed.  */
1087       status->value.sig = target_signal_from_host (sigrc);
1088       break;
1089 #endif
1090     }
1091
1092   return inferior_pid;
1093 }
1094
1095 /* Get ready to modify the registers array.  On machines which store
1096    individual registers, this doesn't need to do anything.  On machines
1097    which store all the registers in one fell swoop, this makes sure
1098    that registers contains all the registers from the program being
1099    debugged.  */
1100
1101 static void
1102 remote_rdp_prepare_to_store ()
1103 {
1104   /* Do nothing, since we can store individual regs */
1105 }
1106
1107 static int
1108 remote_rdp_xfer_inferior_memory (memaddr, myaddr, len, write, target)
1109      CORE_ADDR memaddr;
1110      char *myaddr;
1111      int len;
1112      int write;
1113      struct target_ops *target; /* ignored */
1114 {
1115   /* I infer from D Taylor's code that there's a limit on the amount
1116      we can transfer in one chunk.. */
1117   int done = 0;
1118   while (done < len)
1119     {
1120       int justdone;
1121       int thisbite = len - done;
1122       if (thisbite > RDP_MOUTHFULL)
1123         thisbite = RDP_MOUTHFULL;
1124
1125       QUIT;
1126
1127       if (write)
1128         {
1129           justdone = rdp_write (memaddr + done, myaddr + done, thisbite);
1130         }
1131       else
1132         {
1133           justdone = rdp_read (memaddr + done, myaddr + done, thisbite);
1134         }
1135
1136       done += justdone;
1137
1138       if (justdone != thisbite)
1139         break;
1140     }
1141   return done;
1142 }
1143
1144
1145
1146 struct yn
1147 {
1148   const char *name;
1149   int bit;
1150 };
1151 static struct yn stepinfo[] =
1152 {
1153   {"Step more than one instruction", RDP_INFO_ABOUT_STEP_GT_1},
1154   {"Step to jump", RDP_INFO_ABOUT_STEP_TO_JMP},
1155   {"Step one instruction", RDP_INFO_ABOUT_STEP_1},
1156   {0}
1157 };
1158
1159 static struct yn breakinfo[] =
1160 {
1161   {"comparison breakpoints supported", RDP_INFO_ABOUT_BREAK_COMP},
1162   {"range breakpoints supported", RDP_INFO_ABOUT_BREAK_RANGE},
1163   {"watchpoints for byte reads supported", RDP_INFO_ABOUT_BREAK_BYTE_READ},
1164   {"watchpoints for half-word reads supported", RDP_INFO_ABOUT_BREAK_HALFWORD_READ},
1165   {"watchpoints for word reads supported", RDP_INFO_ABOUT_BREAK_WORD_READ},
1166   {"watchpoints for byte writes supported", RDP_INFO_ABOUT_BREAK_BYTE_WRITE},
1167   {"watchpoints for half-word writes supported", RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE},
1168   {"watchpoints for word writes supported", RDP_INFO_ABOUT_BREAK_WORD_WRITE},
1169   {"mask break/watch-points supported", RDP_INFO_ABOUT_BREAK_MASK},
1170   {"thread-specific breakpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_BREAK},
1171   {"thread-specific watchpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_WATCH},
1172   {"conditional breakpoints supported", RDP_INFO_ABOUT_BREAK_COND},
1173   {0}
1174 };
1175
1176
1177 static void
1178 dump_bits (t, info)
1179      struct yn *t;
1180      int info;
1181 {
1182   while (t->name)
1183     {
1184       printf_unfiltered ("  %-45s : %s\n", t->name, (info & t->bit) ? "Yes" : "No");
1185       t++;
1186     }
1187 }
1188
1189 static void
1190 remote_rdp_files_info (target)
1191      struct target_ops *target;
1192 {
1193   printf_filtered ("Target capabilities:\n");
1194   dump_bits (stepinfo, ds.step_info);
1195   dump_bits (breakinfo, ds.break_info);
1196   printf_unfiltered ("target level RDI %x\n", (ds.target_info >> 5) & 3);
1197 }
1198
1199
1200 /* Define the target subroutine names */
1201
1202 struct target_ops remote_rdp_ops =
1203 {
1204   "rdp",                        /* to_shortname */
1205   /* to_longname */
1206   "Remote Target using the RDProtocol",
1207   /* to_doc */
1208   "Use a remote ARM system which uses the ARM Remote Debugging Protocol",
1209   remote_rdp_open,              /* to_open */
1210   remote_rdp_close,             /* to_close */
1211   NULL,                         /* to_attach */
1212   NULL,                         /* to_detach */
1213   remote_rdp_resume,            /* to_resume */
1214   remote_rdp_wait,              /* to_wait */
1215   remote_rdp_fetch_register,    /* to_fetch_registers */
1216   remote_rdp_store_register,    /* to_store_registers */
1217   remote_rdp_prepare_to_store,  /* to_prepare_to_store */
1218   remote_rdp_xfer_inferior_memory, /* to_xfer_memory */
1219   remote_rdp_files_info,        /* to_files_info */
1220   remote_rdp_insert_breakpoint, /* to_insert_breakpoint */
1221   remote_rdp_remove_breakpoint, /* to_remove_breakpoint */
1222   NULL,                         /* to_terminal_init */
1223   NULL,                         /* to_terminal_inferior */
1224   NULL,                         /* to_terminal_ours_for_output */
1225   NULL,                         /* to_terminal_ours */
1226   NULL,                         /* to_terminal_info */
1227   remote_rdp_kill,              /* to_kill */
1228   generic_load,                 /* to_load */
1229   NULL,                         /* to_lookup_symbol */
1230   NULL,                         /* to_create_inferior */
1231   generic_mourn_inferior,       /* to_mourn_inferior */
1232   0,                            /* to_can_run */
1233   0,                            /* to_notice_signals */
1234   0,                            /* to_thread_alive */
1235   0,                            /* to_stop */
1236   process_stratum,              /* to_stratum */
1237   NULL,                         /* to_next */
1238   1,                            /* to_has_all_memory */
1239   1,                            /* to_has_memory */
1240   1,                            /* to_has_stack */
1241   1,                            /* to_has_registers */
1242   1,                            /* to_has_execution */
1243   NULL,                         /* sections */
1244   NULL,                         /* sections_end */
1245   OPS_MAGIC,                    /* to_magic */
1246 };
1247
1248 void
1249 _initialize_remote_rdp ()
1250 {
1251   add_target (&remote_rdp_ops);
1252 }