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