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