gdb/remote-rdi.c

   1 /* GDB interface to ARM RDI library.
   2
   3    Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software
   4    Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdb_string.h"
  25 #include <fcntl.h>
  26 #include "frame.h"
  27 #include "inferior.h"
  28 #include "bfd.h"
  29 #include "symfile.h"
  30 #include "target.h"
  31 #include "gdbcmd.h"
  32 #include "objfiles.h"
  33 #include "gdb-stabs.h"
  34 #include "gdbthread.h"
  35 #include "gdbcore.h"
  36 #include "breakpoint.h"
  37 #include "completer.h"
  38 #include "regcache.h"
  39 #include "arm-tdep.h"
  40
  41 #ifdef USG
  42 #include <sys/types.h>
  43 #endif
  44
  45 #include <signal.h>
  46
  47 #include "rdi-share/ardi.h"
  48 #include "rdi-share/adp.h"
  49 #include "rdi-share/hsys.h"
  50
  51 extern int isascii (int);
  52
  53 /* Prototypes for local functions */
  54
  55 static void arm_rdi_files_info (struct target_ops *ignore);
  56
  57 static int arm_rdi_xfer_memory (CORE_ADDR memaddr, char *myaddr,
  58                                 int len, int should_write,
  59                                 struct mem_attrib *attrib,
  60                                 struct target_ops *target);
  61
  62 static void arm_rdi_prepare_to_store (void);
  63
  64 static void arm_rdi_fetch_registers (int regno);
  65
  66 static void arm_rdi_resume (ptid_t pid, int step,
  67                             enum target_signal siggnal);
  68
  69 static int arm_rdi_start_remote (char *dummy);
  70
  71 static void arm_rdi_open (char *name, int from_tty);
  72
  73 static void arm_rdi_create_inferior (char *exec_file, char *args, char **env);
  74
  75 static void arm_rdi_close (int quitting);
  76
  77 static void arm_rdi_store_registers (int regno);
  78
  79 static void arm_rdi_mourn (void);
  80
  81 static void arm_rdi_send (char *buf);
  82
  83 static ptid_t arm_rdi_wait (ptid_t ptid, struct target_waitstatus *status);
  84
  85 static void arm_rdi_kill (void);
  86
  87 static void arm_rdi_detach (char *args, int from_tty);
  88
  89 static void arm_rdi_interrupt (int signo);
  90
  91 static void arm_rdi_interrupt_twice (int signo);
  92
  93 static void interrupt_query (void);
  94
  95 static int arm_rdi_insert_breakpoint (CORE_ADDR, char *);
  96
  97 static int arm_rdi_remove_breakpoint (CORE_ADDR, char *);
  98
  99 static char *rdi_error_message (int err);
 100
 101 static enum target_signal rdi_error_signal (int err);
 102
 103 /* Global variables.  */
 104
 105 struct target_ops arm_rdi_ops;
 106
 107 static struct Dbg_ConfigBlock gdb_config;
 108
 109 static struct Dbg_HostosInterface gdb_hostif;
 110
 111 static int max_load_size;
 112
 113 static int execute_status;
 114
 115 /* Send heatbeat packets? */
 116 static int rdi_heartbeat = 0;
 117
 118 /* Target has ROM at address 0. */
 119 static int rom_at_zero = 0;
 120
 121 /* Enable logging? */
 122 static int log_enable = 0;
 123
 124 /* Name of the log file. Default is "rdi.log". */
 125 static char *log_filename;
 126
 127 /* A little list of breakpoints that have been set.  */
 128
 129 static struct local_bp_list_entry
 130   {
 131     CORE_ADDR addr;
 132     PointHandle point;
 133     struct local_bp_list_entry *next;
 134   }
 135  *local_bp_list;
 136 \f
 137
 138 /* Stub for catch_errors.  */
 139
 140 static int
 141 arm_rdi_start_remote (char *dummy)
 142 {
 143   return 1;
 144 }
 145
 146 /* Helper callbacks for the "host interface" structure.  RDI functions call
 147    these to forward output from the target system and so forth.  */
 148
 149 void
 150 voiddummy (void *dummy)
 151 {
 152   fprintf_unfiltered (gdb_stdout, "void dummy\n");
 153 }
 154
 155 static void
 156 myprint (PTR arg, const char *format, va_list ap)
 157 {
 158   vfprintf_unfiltered (gdb_stdout, format, ap);
 159 }
 160
 161 static void
 162 mywritec (PTR arg, int c)
 163 {
 164   if (isascii (c))
 165     fputc_unfiltered (c, gdb_stdout);
 166 }
 167
 168 static int
 169 mywrite (PTR arg, char const *buffer, int len)
 170 {
 171   int i;
 172   char *e;
 173
 174   e = (char *) buffer;
 175   for (i = 0; i < len; i++)
 176     {
 177       if (isascii ((int) *e))
 178         {
 179           fputc_unfiltered ((int) *e, gdb_stdout);
 180           e++;
 181         }
 182     }
 183
 184   return len;
 185 }
 186
 187 static void
 188 mypause (PTR arg)
 189 {
 190 }
 191
 192 /* These last two are tricky as we have to handle the special case of
 193    being interrupted more carefully */
 194
 195 static int
 196 myreadc (PTR arg)
 197 {
 198   return fgetc (stdin);
 199 }
 200
 201 static char *
 202 mygets (PTR arg, char *buffer, int len)
 203 {
 204   return fgets (buffer, len, stdin);
 205 }
 206
 207 /* Prevent multiple calls to angel_RDI_close().  */
 208 static int closed_already = 1;
 209
 210 /* Open a connection to a remote debugger.  NAME is the filename used
 211    for communication.  */
 212
 213 static void
 214 arm_rdi_open (char *name, int from_tty)
 215 {
 216   int rslt, i;
 217   unsigned long arg1, arg2;
 218   char *openArgs = NULL;
 219   char *devName = NULL;
 220   char *p;
 221
 222   if (name == NULL)
 223     error ("To open an RDI connection, you need to specify what serial\n\
 224 device is attached to the remote system (e.g. /dev/ttya).");
 225
 226   /* split name after whitespace, pass tail as arg to open command */
 227
 228   devName = xstrdup (name);
 229   p = strchr (devName, ' ');
 230   if (p)
 231     {
 232       *p = '\0';
 233       ++p;
 234
 235       while (*p == ' ')
 236         ++p;
 237
 238       openArgs = p;
 239     }
 240
 241   /* Make the basic low-level connection.  */
 242
 243   arm_rdi_close (0);
 244   rslt = Adp_OpenDevice (devName, openArgs, rdi_heartbeat);
 245
 246   if (rslt != adp_ok)
 247     error ("Could not open device \"%s\"", name);
 248
 249   gdb_config.bytesex = 2 | (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 1 : 0);
 250   gdb_config.fpe = 1;
 251   gdb_config.rditype = 2;
 252   gdb_config.heartbeat_on = 1;
 253   gdb_config.flags = 2;
 254
 255   gdb_hostif.dbgprint = myprint;
 256   gdb_hostif.dbgpause = mypause;
 257   gdb_hostif.dbgarg = NULL;
 258   gdb_hostif.writec = mywritec;
 259   gdb_hostif.readc = myreadc;
 260   gdb_hostif.write = mywrite;
 261   gdb_hostif.gets = mygets;
 262   gdb_hostif.hostosarg = NULL;
 263   gdb_hostif.reset = voiddummy;
 264
 265   rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL);
 266   if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian)
 267     ;                           /* do nothing, this is the expected return */
 268   else if (rslt)
 269     {
 270       printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
 271       Adp_CloseDevice ();
 272       error ("RDI_open failed\n");
 273     }
 274
 275   rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
 276   if (rslt)
 277     {
 278       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 279     }
 280   rslt = angel_RDI_info (RDIInfo_Points, &arg1, &arg2);
 281   if (rslt)
 282     {
 283       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 284     }
 285   rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
 286   if (rslt)
 287     {
 288       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 289     }
 290   rslt = angel_RDI_info (RDIInfo_CoPro, &arg1, &arg2);
 291   if (rslt)
 292     {
 293       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 294     }
 295   rslt = angel_RDI_info (RDIInfo_SemiHosting, &arg1, &arg2);
 296   if (rslt)
 297     {
 298       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 299     }
 300
 301   rslt = angel_RDI_info (RDIInfo_GetLoadSize, &arg1, &arg2);
 302   if (rslt)
 303     {
 304       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 305     }
 306   max_load_size = arg1;
 307
 308   push_target (&arm_rdi_ops);
 309
 310   target_fetch_registers (-1);
 311
 312   rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
 313   if (rslt)
 314     {
 315       printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
 316     }
 317
 318   arg1 = rom_at_zero ? 0x0 : 0x13b;
 319
 320   rslt = angel_RDI_info (RDIVector_Catch, &arg1, &arg2);
 321   if (rslt)
 322     {
 323       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 324     }
 325
 326   arg1 = (unsigned long) "";
 327   rslt = angel_RDI_info (RDISet_Cmdline, &arg1, &arg2);
 328   if (rslt)
 329     {
 330       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 331     }
 332
 333   /* Clear out any existing records of breakpoints.  */
 334   {
 335     struct local_bp_list_entry *entry, *preventry = NULL;
 336
 337     for (entry = local_bp_list; entry != NULL; entry = entry->next)
 338       {
 339         if (preventry)
 340           xfree (preventry);
 341       }
 342   }
 343
 344   printf_filtered ("Connected to ARM RDI target.\n");
 345   closed_already = 0;
 346   inferior_ptid = pid_to_ptid (42);
 347 }
 348
 349 /* Start an inferior process and set inferior_ptid to its pid.
 350    EXEC_FILE is the file to run.
 351    ARGS is a string containing the arguments to the program.
 352    ENV is the environment vector to pass.  Errors reported with error().
 353    On VxWorks and various standalone systems, we ignore exec_file.  */
 354 /* This is called not only when we first attach, but also when the
 355    user types "run" after having attached.  */
 356
 357 static void
 358 arm_rdi_create_inferior (char *exec_file, char *args, char **env)
 359 {
 360   int len, rslt;
 361   unsigned long arg1, arg2;
 362   char *arg_buf;
 363   CORE_ADDR entry_point;
 364
 365   if (exec_file == 0 || exec_bfd == 0)
 366     error ("No executable file specified.");
 367
 368   entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 369
 370   arm_rdi_kill ();
 371   remove_breakpoints ();
 372   init_wait_for_inferior ();
 373
 374   len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 375   arg_buf = (char *) alloca (len);
 376   arg_buf[0] = '\0';
 377   strcat (arg_buf, exec_file);
 378   strcat (arg_buf, " ");
 379   strcat (arg_buf, args);
 380
 381   inferior_ptid = pid_to_ptid (42);
 382   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 383
 384   if (env != NULL)
 385     {
 386       while (*env)
 387         {
 388           if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
 389             {
 390               unsigned long top_of_memory;
 391               char *end_of_num;
 392
 393               /* Set up memory limit */
 394               top_of_memory = strtoul (*env + sizeof ("MEMSIZE=") - 1,
 395                                        &end_of_num, 0);
 396               printf_filtered ("Setting top-of-memory to 0x%lx\n",
 397                                top_of_memory);
 398
 399               rslt = angel_RDI_info (RDIInfo_SetTopMem, &top_of_memory, &arg2);
 400               if (rslt)
 401                 {
 402                   printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 403                 }
 404             }
 405           env++;
 406         }
 407     }
 408
 409   arg1 = (unsigned long) arg_buf;
 410   rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *) arg_buf, &arg2);
 411   if (rslt)
 412     {
 413       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 414     }
 415
 416   proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
 417 }
 418
 419 /* This takes a program previously attached to and detaches it.  After
 420    this is done, GDB can be used to debug some other program.  We
 421    better not have left any breakpoints in the target program or it'll
 422    die when it hits one.  */
 423
 424 static void
 425 arm_rdi_detach (char *args, int from_tty)
 426 {
 427   pop_target ();
 428 }
 429
 430 /* Clean up connection to a remote debugger.  */
 431
 432 static void
 433 arm_rdi_close (int quitting)
 434 {
 435   int rslt;
 436
 437   if (!closed_already)
 438     {
 439       rslt = angel_RDI_close ();
 440       if (rslt)
 441         {
 442           printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt));
 443         }
 444       closed_already = 1;
 445       inferior_ptid = null_ptid;
 446       Adp_CloseDevice ();
 447       generic_mourn_inferior ();
 448     }
 449 }
 450 \f
 451 /* Tell the remote machine to resume.  */
 452
 453 static void
 454 arm_rdi_resume (ptid_t ptid, int step, enum target_signal siggnal)
 455 {
 456   int rslt;
 457   PointHandle point;
 458
 459   if (0 /* turn on when hardware supports single-stepping */ )
 460     {
 461       rslt = angel_RDI_step (1, &point);
 462       if (rslt)
 463         {
 464           printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt));
 465         }
 466     }
 467   else
 468     {
 469       char handle[4];
 470       CORE_ADDR pc;
 471
 472       if (step)
 473         {
 474           pc = read_register (ARM_PC_REGNUM);
 475           pc = arm_get_next_pc (pc);
 476           arm_rdi_insert_breakpoint (pc, handle);
 477         }
 478       execute_status = rslt = angel_RDI_execute (&point);
 479       if (rslt == RDIError_BreakpointReached)
 480         ;
 481       else if (rslt)
 482         {
 483           printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt));
 484         }
 485       if (step)
 486         {
 487           arm_rdi_remove_breakpoint (pc, handle);
 488         }
 489     }
 490 }
 491 \f
 492 /* Send ^C to target to halt it.  Target will respond, and send us a
 493    packet.  */
 494
 495 static void
 496 arm_rdi_interrupt (int signo)
 497 {
 498 }
 499
 500 static void (*ofunc) ();
 501
 502 /* The user typed ^C twice.  */
 503 static void
 504 arm_rdi_interrupt_twice (int signo)
 505 {
 506 }
 507
 508 /* Ask the user what to do when an interrupt is received.  */
 509
 510 static void
 511 interrupt_query (void)
 512 {
 513 }
 514
 515 /* Wait until the remote machine stops, then return, storing status in
 516    STATUS just as `wait' would.  Returns "pid" (though it's not clear
 517    what, if anything, that means in the case of this target).  */
 518
 519 static ptid_t
 520 arm_rdi_wait (ptid_t ptid, struct target_waitstatus *status)
 521 {
 522   status->kind = (execute_status == RDIError_NoError ?
 523                   TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED);
 524
 525   /* convert stopped code from target into right signal */
 526   status->value.sig = rdi_error_signal (execute_status);
 527
 528   return inferior_ptid;
 529 }
 530
 531 /* Read the remote registers into the block REGS.  */
 532
 533 /* ARGSUSED */
 534 static void
 535 arm_rdi_fetch_registers (int regno)
 536 {
 537   int rslt, rdi_regmask;
 538   unsigned long rawreg, rawregs[32];
 539   char cookedreg[4];
 540
 541   if (regno == -1)
 542     {
 543       rslt = angel_RDI_CPUread (255, 0x27fff, rawregs);
 544       if (rslt)
 545         {
 546           printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
 547         }
 548
 549       for (regno = 0; regno < 15; regno++)
 550         {
 551           store_unsigned_integer (cookedreg, 4, rawregs[regno]);
 552           supply_register (regno, (char *) cookedreg);
 553         }
 554       store_unsigned_integer (cookedreg, 4, rawregs[15]);
 555       supply_register (ARM_PS_REGNUM, (char *) cookedreg);
 556       arm_rdi_fetch_registers (ARM_PC_REGNUM);
 557     }
 558   else
 559     {
 560       if (regno == ARM_PC_REGNUM)
 561         rdi_regmask = RDIReg_PC;
 562       else if (regno == ARM_PS_REGNUM)
 563         rdi_regmask = RDIReg_CPSR;
 564       else if (regno < 0 || regno > 15)
 565         {
 566           rawreg = 0;
 567           supply_register (regno, (char *) &rawreg);
 568           return;
 569         }
 570       else
 571         rdi_regmask = 1 << regno;
 572
 573       rslt = angel_RDI_CPUread (255, rdi_regmask, &rawreg);
 574       if (rslt)
 575         {
 576           printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
 577         }
 578       store_unsigned_integer (cookedreg, 4, rawreg);
 579       supply_register (regno, (char *) cookedreg);
 580     }
 581 }
 582
 583 static void
 584 arm_rdi_prepare_to_store (void)
 585 {
 586   /* Nothing to do.  */
 587 }
 588
 589 /* Store register REGNO, or all registers if REGNO == -1, from the contents
 590    of REGISTERS.  FIXME: ignores errors.  */
 591
 592 static void
 593 arm_rdi_store_registers (int regno)
 594 {
 595   int rslt, rdi_regmask;
 596
 597   /* These need to be able to take 'floating point register' contents */
 598   unsigned long rawreg[3], rawerreg[3];
 599
 600   if (regno == -1)
 601     {
 602       for (regno = 0; regno < NUM_REGS; regno++)
 603         arm_rdi_store_registers (regno);
 604     }
 605   else
 606     {
 607       read_register_gen (regno, (char *) rawreg);
 608       /* RDI manipulates data in host byte order, so convert now. */
 609       store_unsigned_integer (rawerreg, 4, rawreg[0]);
 610
 611       if (regno == ARM_PC_REGNUM)
 612         rdi_regmask = RDIReg_PC;
 613       else if (regno == ARM_PS_REGNUM)
 614         rdi_regmask = RDIReg_CPSR;
 615       else if (regno < 0 || regno > 15)
 616         return;
 617       else
 618         rdi_regmask = 1 << regno;
 619
 620       rslt = angel_RDI_CPUwrite (255, rdi_regmask, rawerreg);
 621       if (rslt)
 622         {
 623           printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt));
 624         }
 625     }
 626 }
 627 \f
 628 /* Read or write LEN bytes from inferior memory at MEMADDR,
 629    transferring to or from debugger address MYADDR.  Write to inferior
 630    if SHOULD_WRITE is nonzero.  Returns length of data written or
 631    read; 0 for error.  TARGET is unused.  */
 632
 633 /* ARGSUSED */
 634 static int
 635 arm_rdi_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 636                      int should_write, struct mem_attrib *attrib,
 637                      struct target_ops *target)
 638 {
 639   int rslt, i;
 640
 641   if (should_write)
 642     {
 643       rslt = angel_RDI_write (myaddr, memaddr, &len);
 644       if (rslt)
 645         {
 646           printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt));
 647         }
 648     }
 649   else
 650     {
 651       rslt = angel_RDI_read (memaddr, myaddr, &len);
 652       if (rslt)
 653         {
 654           printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt));
 655           len = 0;
 656         }
 657     }
 658   return len;
 659 }
 660 \f
 661 /* Display random info collected from the target.  */
 662
 663 static void
 664 arm_rdi_files_info (struct target_ops *ignore)
 665 {
 666   char *file = "nothing";
 667   int rslt;
 668   unsigned long arg1, arg2;
 669
 670   rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
 671   if (rslt)
 672     {
 673       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 674     }
 675   if (arg1 & (1 << 15))
 676     printf_filtered ("Target supports Thumb code.\n");
 677   if (arg1 & (1 << 14))
 678     printf_filtered ("Target can do profiling.\n");
 679   if (arg1 & (1 << 4))
 680     printf_filtered ("Target is real hardware.\n");
 681
 682   rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
 683   if (rslt)
 684     {
 685       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 686     }
 687   printf_filtered ("Target can%s single-step.\n", (arg1 & 0x4 ? "" : "not"));
 688
 689   rslt = angel_RDI_info (RDIInfo_Icebreaker, &arg1, &arg2);
 690   if (rslt)
 691     {
 692       printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
 693     }
 694   else
 695     printf_filtered ("Target includes an EmbeddedICE.\n");
 696 }
 697 \f
 698 static void
 699 arm_rdi_kill (void)
 700 {
 701   int rslt;
 702
 703   rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
 704   if (rslt)
 705     {
 706       printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
 707     }
 708 }
 709
 710 static void
 711 arm_rdi_mourn_inferior (void)
 712 {
 713   /* We remove the inserted breakpoints in case the user wants to
 714      issue another target and load commands to rerun his application;
 715      This is something that wouldn't work on a native target, for instance,
 716      as the process goes away when the inferior exits, but it works with
 717      some remote targets like this one.  That is why this is done here. */
 718   remove_breakpoints();
 719   unpush_target (&arm_rdi_ops);
 720   generic_mourn_inferior ();
 721 }
 722 \f
 723 /* While the RDI library keeps track of its own breakpoints, we need
 724    to remember "handles" so that we can delete them later.  Since
 725    breakpoints get used for stepping, be careful not to leak memory
 726    here.  */
 727
 728 static int
 729 arm_rdi_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
 730 {
 731   int rslt;
 732   PointHandle point;
 733   struct local_bp_list_entry *entry;
 734   int type = RDIPoint_EQ;
 735
 736   if (arm_pc_is_thumb (addr) || arm_pc_is_thumb_dummy (addr))
 737     type |= RDIPoint_16Bit;
 738   rslt = angel_RDI_setbreak (addr, type, 0, &point);
 739   if (rslt)
 740     {
 741       printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt));
 742     }
 743   entry =
 744     (struct local_bp_list_entry *) xmalloc (sizeof (struct local_bp_list_entry));
 745   entry->addr = addr;
 746   entry->point = point;
 747   entry->next = local_bp_list;
 748   local_bp_list = entry;
 749   return rslt;
 750 }
 751
 752 static int
 753 arm_rdi_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 754 {
 755   int rslt;
 756   PointHandle point;
 757   struct local_bp_list_entry *entry, *preventry;
 758
 759   for (entry = local_bp_list; entry != NULL; entry = entry->next)
 760     {
 761       if (entry->addr == addr)
 762         {
 763           break;
 764         }
 765       preventry = entry;
 766     }
 767   if (entry)
 768     {
 769       rslt = angel_RDI_clearbreak (entry->point);
 770       if (rslt)
 771         {
 772           printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt));
 773         }
 774       /* Delete the breakpoint entry locally.  */
 775       if (entry == local_bp_list)
 776         {
 777           local_bp_list = entry->next;
 778         }
 779       else
 780         {
 781           preventry->next = entry->next;
 782         }
 783       xfree (entry);
 784     }
 785   return 0;
 786 }
 787 \f
 788 static char *
 789 rdi_error_message (int err)
 790 {
 791   switch (err)
 792     {
 793     case RDIError_NoError:
 794       return "no error";
 795     case RDIError_Reset:
 796       return "debuggee reset";
 797     case RDIError_UndefinedInstruction:
 798       return "undefined instruction";
 799     case RDIError_SoftwareInterrupt:
 800       return "SWI trapped";
 801     case RDIError_PrefetchAbort:
 802       return "prefetch abort, execution ran into unmapped memory?";
 803     case RDIError_DataAbort:
 804       return "data abort, no memory at specified address?";
 805     case RDIError_AddressException:
 806       return "address exception, access >26bit in 26bit mode";
 807     case RDIError_IRQ:
 808       return "IRQ, interrupt trapped";
 809     case RDIError_FIQ:
 810       return "FIQ, fast interrupt trapped";
 811     case RDIError_Error:
 812       return "a miscellaneous type of error";
 813     case RDIError_BranchThrough0:
 814       return "branch through location 0";
 815     case RDIError_NotInitialised:
 816       return "internal error, RDI_open not called first";
 817     case RDIError_UnableToInitialise:
 818       return "internal error, target world is broken";
 819     case RDIError_WrongByteSex:
 820       return "See Operator: WrongByteSex";
 821     case RDIError_UnableToTerminate:
 822       return "See Operator: Unable to Terminate";
 823     case RDIError_BadInstruction:
 824       return "bad instruction, illegal to execute this instruction";
 825     case RDIError_IllegalInstruction:
 826       return "illegal instruction, the effect of executing it is undefined";
 827     case RDIError_BadCPUStateSetting:
 828       return "internal error, tried to set SPSR of user mode";
 829     case RDIError_UnknownCoPro:
 830       return "unknown co-processor";
 831     case RDIError_UnknownCoProState:
 832       return "cannot execute co-processor request";
 833     case RDIError_BadCoProState:
 834       return "recognizably broken co-processor request";
 835     case RDIError_BadPointType:
 836       return "internal error, bad point yype";
 837     case RDIError_UnimplementedType:
 838       return "internal error, unimplemented type";
 839     case RDIError_BadPointSize:
 840       return "internal error, bad point size";
 841     case RDIError_UnimplementedSize:
 842       return "internal error, unimplemented size";
 843     case RDIError_NoMorePoints:
 844       return "last break/watch point was used";
 845     case RDIError_BreakpointReached:
 846       return "breakpoint reached";
 847     case RDIError_WatchpointAccessed:
 848       return "watchpoint accessed";
 849     case RDIError_NoSuchPoint:
 850       return "attempted to clear non-existent break/watch point";
 851     case RDIError_ProgramFinishedInStep:
 852       return "end of the program reached while stepping";
 853     case RDIError_UserInterrupt:
 854       return "you pressed Escape";
 855     case RDIError_CantSetPoint:
 856       return "no more break/watch points available";
 857     case RDIError_IncompatibleRDILevels:
 858       return "incompatible RDI levels";
 859     case RDIError_LittleEndian:
 860       return "debuggee is little endian";
 861     case RDIError_BigEndian:
 862       return "debuggee is big endian";
 863     case RDIError_SoftInitialiseError:
 864       return "recoverable error in RDI initialization";
 865     case RDIError_InsufficientPrivilege:
 866       return "internal error, supervisor state not accessible to monitor";
 867     case RDIError_UnimplementedMessage:
 868       return "internal error, unimplemented message";
 869     case RDIError_UndefinedMessage:
 870       return "internal error, undefined message";
 871     default:
 872       return "undefined error message, should reset target";
 873     }
 874 }
 875
 876 /* Convert the ARM error messages to signals that GDB knows about.  */
 877
 878 static enum target_signal
 879 rdi_error_signal (int err)
 880 {
 881   switch (err)
 882     {
 883     case RDIError_NoError:
 884       return 0;
 885     case RDIError_Reset:
 886       return TARGET_SIGNAL_TERM;        /* ??? */
 887     case RDIError_UndefinedInstruction:
 888       return TARGET_SIGNAL_ILL;
 889     case RDIError_SoftwareInterrupt:
 890     case RDIError_PrefetchAbort:
 891     case RDIError_DataAbort:
 892       return TARGET_SIGNAL_TRAP;
 893     case RDIError_AddressException:
 894       return TARGET_SIGNAL_SEGV;
 895     case RDIError_IRQ:
 896     case RDIError_FIQ:
 897       return TARGET_SIGNAL_TRAP;
 898     case RDIError_Error:
 899       return TARGET_SIGNAL_TERM;
 900     case RDIError_BranchThrough0:
 901       return TARGET_SIGNAL_TRAP;
 902     case RDIError_NotInitialised:
 903     case RDIError_UnableToInitialise:
 904     case RDIError_WrongByteSex:
 905     case RDIError_UnableToTerminate:
 906       return TARGET_SIGNAL_UNKNOWN;
 907     case RDIError_BadInstruction:
 908     case RDIError_IllegalInstruction:
 909       return TARGET_SIGNAL_ILL;
 910     case RDIError_BadCPUStateSetting:
 911     case RDIError_UnknownCoPro:
 912     case RDIError_UnknownCoProState:
 913     case RDIError_BadCoProState:
 914     case RDIError_BadPointType:
 915     case RDIError_UnimplementedType:
 916     case RDIError_BadPointSize:
 917     case RDIError_UnimplementedSize:
 918     case RDIError_NoMorePoints:
 919       return TARGET_SIGNAL_UNKNOWN;
 920     case RDIError_BreakpointReached:
 921     case RDIError_WatchpointAccessed:
 922       return TARGET_SIGNAL_TRAP;
 923     case RDIError_NoSuchPoint:
 924     case RDIError_ProgramFinishedInStep:
 925       return TARGET_SIGNAL_UNKNOWN;
 926     case RDIError_UserInterrupt:
 927       return TARGET_SIGNAL_INT;
 928     case RDIError_IncompatibleRDILevels:
 929     case RDIError_LittleEndian:
 930     case RDIError_BigEndian:
 931     case RDIError_SoftInitialiseError:
 932     case RDIError_InsufficientPrivilege:
 933     case RDIError_UnimplementedMessage:
 934     case RDIError_UndefinedMessage:
 935     default:
 936       return TARGET_SIGNAL_UNKNOWN;
 937     }
 938 }
 939
 940 static void
 941 arm_rdi_stop(void)
 942 {
 943   angel_RDI_stop_request();
 944 }
 945
 946 \f
 947 /* Define the target operations structure.  */
 948
 949 static void
 950 init_rdi_ops (void)
 951 {
 952   arm_rdi_ops.to_shortname = "rdi";
 953   arm_rdi_ops.to_longname = "ARM RDI";
 954   arm_rdi_ops.to_doc = "Use a remote ARM-based computer; via the RDI library.\n\
 955 Specify the serial device it is connected to (e.g. /dev/ttya).";
 956   arm_rdi_ops.to_open = arm_rdi_open;
 957   arm_rdi_ops.to_close = arm_rdi_close;
 958   arm_rdi_ops.to_detach = arm_rdi_detach;
 959   arm_rdi_ops.to_resume = arm_rdi_resume;
 960   arm_rdi_ops.to_wait = arm_rdi_wait;
 961   arm_rdi_ops.to_stop = arm_rdi_stop;
 962   arm_rdi_ops.to_fetch_registers = arm_rdi_fetch_registers;
 963   arm_rdi_ops.to_store_registers = arm_rdi_store_registers;
 964   arm_rdi_ops.to_prepare_to_store = arm_rdi_prepare_to_store;
 965   arm_rdi_ops.to_xfer_memory = arm_rdi_xfer_memory;
 966   arm_rdi_ops.to_files_info = arm_rdi_files_info;
 967   arm_rdi_ops.to_insert_breakpoint = arm_rdi_insert_breakpoint;
 968   arm_rdi_ops.to_remove_breakpoint = arm_rdi_remove_breakpoint;
 969   arm_rdi_ops.to_kill = arm_rdi_kill;
 970   arm_rdi_ops.to_load = generic_load;
 971   arm_rdi_ops.to_create_inferior = arm_rdi_create_inferior;
 972   arm_rdi_ops.to_mourn_inferior = arm_rdi_mourn_inferior;
 973   arm_rdi_ops.to_stratum = process_stratum;
 974   arm_rdi_ops.to_has_all_memory = 1;
 975   arm_rdi_ops.to_has_memory = 1;
 976   arm_rdi_ops.to_has_stack = 1;
 977   arm_rdi_ops.to_has_registers = 1;
 978   arm_rdi_ops.to_has_execution = 1;
 979   arm_rdi_ops.to_magic = OPS_MAGIC;
 980 }
 981
 982 static void
 983 rdilogfile_command (char *arg, int from_tty)
 984 {
 985   if (!arg || strlen (arg) == 0)
 986     {
 987       printf_filtered ("rdi log file is '%s'\n", log_filename);
 988       return;
 989     }
 990
 991   if (log_filename)
 992     xfree (log_filename);
 993
 994   log_filename = xstrdup (arg);
 995
 996   Adp_SetLogfile (log_filename);
 997 }
 998
 999 static void
1000 rdilogenable_command (char *args, int from_tty)
1001 {
1002   if (!args || strlen (args) == 0)
1003     {
1004       printf_filtered ("rdi log is %s\n", log_enable ? "enabled" : "disabled");
1005       return;
1006     }
1007
1008   if (!strcasecmp (args, "1") ||
1009       !strcasecmp (args, "y") ||
1010       !strcasecmp (args, "yes") ||
1011       !strcasecmp (args, "on") ||
1012       !strcasecmp (args, "t") ||
1013       !strcasecmp (args, "true"))
1014     Adp_SetLogEnable (log_enable = 1);
1015   else if (!strcasecmp (args, "0") ||
1016            !strcasecmp (args, "n") ||
1017            !strcasecmp (args, "no") ||
1018            !strcasecmp (args, "off") ||
1019            !strcasecmp (args, "f") ||
1020            !strcasecmp (args, "false"))
1021     Adp_SetLogEnable (log_enable = 0);
1022   else
1023     printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
1024                      "              try y or n\n", args);
1025 }
1026
1027 void
1028 _initialize_remote_rdi (void)
1029 {
1030   struct cmd_list_element *c;
1031
1032   init_rdi_ops ();
1033   add_target (&arm_rdi_ops);
1034
1035   log_filename = xstrdup ("rdi.log");
1036   Adp_SetLogfile (log_filename);
1037   Adp_SetLogEnable (log_enable);
1038
1039   c = add_cmd ("rdilogfile", class_maintenance,
1040                rdilogfile_command,
1041                "Set filename for ADP packet log.\n\
1042 This file is used to log Angel Debugger Protocol packets.\n\
1043 With a single argument, sets the logfile name to that value.\n\
1044 Without an argument, shows the current logfile name.\n\
1045 See also: rdilogenable\n",
1046            &maintenancelist);
1047   set_cmd_completer (c, filename_completer);
1048
1049   add_cmd ("rdilogenable", class_maintenance,
1050            rdilogenable_command,
1051            "Set enable logging of ADP packets.\n\
1052 This will log ADP packets exchanged between gdb and the\n\
1053 rdi target device.\n\
1054 An argument of 1,t,true,y,yes will enable.\n\
1055 An argument of 0,f,false,n,no will disabled.\n\
1056 Withough an argument, it will display current state.\n",
1057            &maintenancelist);
1058
1059   add_show_from_set
1060     (add_set_cmd ("rdiromatzero", no_class,
1061                   var_boolean, (char *) &rom_at_zero,
1062                   "Set target has ROM at addr 0.\n\
1063 A true value disables vector catching, false enables vector catching.\n\
1064 This is evaluated at the time the 'target rdi' command is executed\n",
1065                   &setlist),
1066      &showlist);
1067
1068   add_show_from_set
1069     (add_set_cmd ("rdiheartbeat", no_class,
1070                   var_boolean, (char *) &rdi_heartbeat,
1071                   "Set enable for ADP heartbeat packets.\n\
1072 I don't know why you would want this. If you enable them,\n\
1073 it will confuse ARM and EPI JTAG interface boxes as well\n\
1074 as the Angel Monitor.\n",
1075                   &setlist),
1076      &showlist);
1077 }
1078
1079 /* A little dummy to make linking with the library succeed. */
1080
1081 int
1082 Fail (void)
1083 {
1084   return 0;
1085 }