gdb/remote-rdi.c

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