sim/rx/gdb-if.c

   1 /* gdb-if.c -- sim interface to GDB.
   2
   3 Copyright (C) 2008-2015 Free Software Foundation, Inc.
   4 Contributed by Red Hat, Inc.
   5
   6 This file is part of the GNU simulators.
   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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <assert.h>
  24 #include <signal.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <stdlib.h>
  28
  29 #include "ansidecl.h"
  30 #include "gdb/callback.h"
  31 #include "gdb/remote-sim.h"
  32 #include "gdb/signals.h"
  33 #include "gdb/sim-rx.h"
  34
  35 #include "cpu.h"
  36 #include "mem.h"
  37 #include "load.h"
  38 #include "syscalls.h"
  39 #include "err.h"
  40 #include "trace.h"
  41
  42 /* Ideally, we'd wrap up all the minisim's data structures in an
  43    object and pass that around.  However, neither GDB nor run needs
  44    that ability.
  45
  46    So we just have one instance, that lives in global variables, and
  47    each time we open it, we re-initialize it.  */
  48 struct sim_state
  49 {
  50   const char *message;
  51 };
  52
  53 static struct sim_state the_minisim = {
  54   "This is the sole rx minisim instance.  See libsim.a's global variables."
  55 };
  56
  57 static int rx_sim_is_open;
  58
  59 SIM_DESC
  60 sim_open (SIM_OPEN_KIND kind,
  61           struct host_callback_struct *callback,
  62           struct bfd *abfd, char **argv)
  63 {
  64   if (rx_sim_is_open)
  65     fprintf (stderr, "rx minisim: re-opened sim\n");
  66
  67   /* The 'run' interface doesn't use this function, so we don't care
  68      about KIND; it's always SIM_OPEN_DEBUG.  */
  69   if (kind != SIM_OPEN_DEBUG)
  70     fprintf (stderr, "rx minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
  71              kind);
  72
  73   set_callbacks (callback);
  74
  75   /* We don't expect any command-line arguments.  */
  76
  77   init_mem ();
  78   init_regs ();
  79   execution_error_init_debugger ();
  80
  81   sim_disasm_init (abfd);
  82   rx_sim_is_open = 1;
  83   return &the_minisim;
  84 }
  85
  86 static void
  87 check_desc (SIM_DESC sd)
  88 {
  89   if (sd != &the_minisim)
  90     fprintf (stderr, "rx minisim: desc != &the_minisim\n");
  91 }
  92
  93 void
  94 sim_close (SIM_DESC sd, int quitting)
  95 {
  96   check_desc (sd);
  97
  98   /* Not much to do.  At least free up our memory.  */
  99   init_mem ();
 100
 101   rx_sim_is_open = 0;
 102 }
 103
 104 static bfd *
 105 open_objfile (const char *filename)
 106 {
 107   bfd *prog = bfd_openr (filename, 0);
 108
 109   if (!prog)
 110     {
 111       fprintf (stderr, "Can't read %s\n", filename);
 112       return 0;
 113     }
 114
 115   if (!bfd_check_format (prog, bfd_object))
 116     {
 117       fprintf (stderr, "%s not a rx program\n", filename);
 118       return 0;
 119     }
 120
 121   return prog;
 122 }
 123
 124 static struct swap_list
 125 {
 126   bfd_vma start, end;
 127   struct swap_list *next;
 128 } *swap_list = NULL;
 129
 130 static void
 131 free_swap_list (void)
 132 {
 133   while (swap_list)
 134     {
 135       struct swap_list *next = swap_list->next;
 136       free (swap_list);
 137       swap_list = next;
 138     }
 139 }
 140
 141 /* When running in big endian mode, we must do an additional
 142    byte swap of memory areas used to hold instructions.  See
 143    the comment preceding rx_load in load.c to see why this is
 144    so.
 145
 146    Construct a list of memory areas that must be byte swapped.
 147    This list will be consulted when either reading or writing
 148    memory.  */
 149
 150 static void
 151 build_swap_list (struct bfd *abfd)
 152 {
 153   asection *s;
 154   free_swap_list ();
 155
 156   /* Nothing to do when in little endian mode.  */
 157   if (!rx_big_endian)
 158     return;
 159
 160   for (s = abfd->sections; s; s = s->next)
 161     {
 162       if ((s->flags & SEC_LOAD) && (s->flags & SEC_CODE))
 163         {
 164           struct swap_list *sl;
 165           bfd_size_type size;
 166
 167           size = bfd_get_section_size (s);
 168           if (size <= 0)
 169             continue;
 170
 171           sl = malloc (sizeof (struct swap_list));
 172           assert (sl != NULL);
 173           sl->next = swap_list;
 174           sl->start = bfd_section_lma (abfd, s);
 175           sl->end = sl->start + size;
 176           swap_list = sl;
 177         }
 178     }
 179 }
 180
 181 static int
 182 addr_in_swap_list (bfd_vma addr)
 183 {
 184   struct swap_list *s;
 185
 186   for (s = swap_list; s; s = s->next)
 187     {
 188       if (s->start <= addr && addr < s->end)
 189         return 1;
 190     }
 191   return 0;
 192 }
 193
 194 SIM_RC
 195 sim_load (SIM_DESC sd, const char *prog, struct bfd *abfd, int from_tty)
 196 {
 197   check_desc (sd);
 198
 199   if (!abfd)
 200     abfd = open_objfile (prog);
 201   if (!abfd)
 202     return SIM_RC_FAIL;
 203
 204   rx_load (abfd, get_callbacks ());
 205   build_swap_list (abfd);
 206
 207   return SIM_RC_OK;
 208 }
 209
 210 SIM_RC
 211 sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env)
 212 {
 213   check_desc (sd);
 214
 215   if (abfd)
 216     {
 217       rx_load (abfd, NULL);
 218       build_swap_list (abfd);
 219     }
 220
 221   return SIM_RC_OK;
 222 }
 223
 224 int
 225 sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
 226 {
 227   int i;
 228
 229   check_desc (sd);
 230
 231   if (mem == 0)
 232     return 0;
 233
 234   execution_error_clear_last_error ();
 235
 236   for (i = 0; i < length; i++)
 237     {
 238       bfd_vma addr = mem + i;
 239       int do_swap = addr_in_swap_list (addr);
 240       buf[i] = mem_get_qi (addr ^ (do_swap ? 3 : 0));
 241
 242       if (execution_error_get_last_error () != SIM_ERR_NONE)
 243         return i;
 244     }
 245
 246   return length;
 247 }
 248
 249 int
 250 sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length)
 251 {
 252   int i;
 253
 254   check_desc (sd);
 255
 256   execution_error_clear_last_error ();
 257
 258   for (i = 0; i < length; i++)
 259     {
 260       bfd_vma addr = mem + i;
 261       int do_swap = addr_in_swap_list (addr);
 262       mem_put_qi (addr ^ (do_swap ? 3 : 0), buf[i]);
 263
 264       if (execution_error_get_last_error () != SIM_ERR_NONE)
 265         return i;
 266     }
 267
 268   return length;
 269 }
 270
 271 /* Read the LENGTH bytes at BUF as an little-endian value.  */
 272 static DI
 273 get_le (unsigned char *buf, int length)
 274 {
 275   DI acc = 0;
 276   while (--length >= 0)
 277     acc = (acc << 8) + buf[length];
 278
 279   return acc;
 280 }
 281
 282 /* Read the LENGTH bytes at BUF as a big-endian value.  */
 283 static DI
 284 get_be (unsigned char *buf, int length)
 285 {
 286   DI acc = 0;
 287   while (length-- > 0)
 288     acc = (acc << 8) + *buf++;
 289
 290   return acc;
 291 }
 292
 293 /* Store VAL as a little-endian value in the LENGTH bytes at BUF.  */
 294 static void
 295 put_le (unsigned char *buf, int length, DI val)
 296 {
 297   int i;
 298
 299   for (i = 0; i < length; i++)
 300     {
 301       buf[i] = val & 0xff;
 302       val >>= 8;
 303     }
 304 }
 305
 306 /* Store VAL as a big-endian value in the LENGTH bytes at BUF.  */
 307 static void
 308 put_be (unsigned char *buf, int length, DI val)
 309 {
 310   int i;
 311
 312   for (i = length-1; i >= 0; i--)
 313     {
 314       buf[i] = val & 0xff;
 315       val >>= 8;
 316     }
 317 }
 318
 319
 320 static int
 321 check_regno (enum sim_rx_regnum regno)
 322 {
 323   return 0 <= regno && regno < sim_rx_num_regs;
 324 }
 325
 326 static size_t
 327 reg_size (enum sim_rx_regnum regno)
 328 {
 329   size_t size;
 330
 331   switch (regno)
 332     {
 333     case sim_rx_r0_regnum:
 334       size = sizeof (regs.r[0]);
 335       break;
 336     case sim_rx_r1_regnum:
 337       size = sizeof (regs.r[1]);
 338       break;
 339     case sim_rx_r2_regnum:
 340       size = sizeof (regs.r[2]);
 341       break;
 342     case sim_rx_r3_regnum:
 343       size = sizeof (regs.r[3]);
 344       break;
 345     case sim_rx_r4_regnum:
 346       size = sizeof (regs.r[4]);
 347       break;
 348     case sim_rx_r5_regnum:
 349       size = sizeof (regs.r[5]);
 350       break;
 351     case sim_rx_r6_regnum:
 352       size = sizeof (regs.r[6]);
 353       break;
 354     case sim_rx_r7_regnum:
 355       size = sizeof (regs.r[7]);
 356       break;
 357     case sim_rx_r8_regnum:
 358       size = sizeof (regs.r[8]);
 359       break;
 360     case sim_rx_r9_regnum:
 361       size = sizeof (regs.r[9]);
 362       break;
 363     case sim_rx_r10_regnum:
 364       size = sizeof (regs.r[10]);
 365       break;
 366     case sim_rx_r11_regnum:
 367       size = sizeof (regs.r[11]);
 368       break;
 369     case sim_rx_r12_regnum:
 370       size = sizeof (regs.r[12]);
 371       break;
 372     case sim_rx_r13_regnum:
 373       size = sizeof (regs.r[13]);
 374       break;
 375     case sim_rx_r14_regnum:
 376       size = sizeof (regs.r[14]);
 377       break;
 378     case sim_rx_r15_regnum:
 379       size = sizeof (regs.r[15]);
 380       break;
 381     case sim_rx_isp_regnum:
 382       size = sizeof (regs.r_isp);
 383       break;
 384     case sim_rx_usp_regnum:
 385       size = sizeof (regs.r_usp);
 386       break;
 387     case sim_rx_intb_regnum:
 388       size = sizeof (regs.r_intb);
 389       break;
 390     case sim_rx_pc_regnum:
 391       size = sizeof (regs.r_pc);
 392       break;
 393     case sim_rx_ps_regnum:
 394       size = sizeof (regs.r_psw);
 395       break;
 396     case sim_rx_bpc_regnum:
 397       size = sizeof (regs.r_bpc);
 398       break;
 399     case sim_rx_bpsw_regnum:
 400       size = sizeof (regs.r_bpsw);
 401       break;
 402     case sim_rx_fintv_regnum:
 403       size = sizeof (regs.r_fintv);
 404       break;
 405     case sim_rx_fpsw_regnum:
 406       size = sizeof (regs.r_fpsw);
 407       break;
 408     case sim_rx_acc_regnum:
 409       size = sizeof (regs.r_acc);
 410       break;
 411     default:
 412       size = 0;
 413       break;
 414     }
 415   return size;
 416 }
 417
 418 int
 419 sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
 420 {
 421   size_t size;
 422   DI val;
 423
 424   check_desc (sd);
 425
 426   if (!check_regno (regno))
 427     return 0;
 428
 429   size = reg_size (regno);
 430
 431   if (length != size)
 432     return 0;
 433
 434   switch (regno)
 435     {
 436     case sim_rx_r0_regnum:
 437       val = get_reg (0);
 438       break;
 439     case sim_rx_r1_regnum:
 440       val = get_reg (1);
 441       break;
 442     case sim_rx_r2_regnum:
 443       val = get_reg (2);
 444       break;
 445     case sim_rx_r3_regnum:
 446       val = get_reg (3);
 447       break;
 448     case sim_rx_r4_regnum:
 449       val = get_reg (4);
 450       break;
 451     case sim_rx_r5_regnum:
 452       val = get_reg (5);
 453       break;
 454     case sim_rx_r6_regnum:
 455       val = get_reg (6);
 456       break;
 457     case sim_rx_r7_regnum:
 458       val = get_reg (7);
 459       break;
 460     case sim_rx_r8_regnum:
 461       val = get_reg (8);
 462       break;
 463     case sim_rx_r9_regnum:
 464       val = get_reg (9);
 465       break;
 466     case sim_rx_r10_regnum:
 467       val = get_reg (10);
 468       break;
 469     case sim_rx_r11_regnum:
 470       val = get_reg (11);
 471       break;
 472     case sim_rx_r12_regnum:
 473       val = get_reg (12);
 474       break;
 475     case sim_rx_r13_regnum:
 476       val = get_reg (13);
 477       break;
 478     case sim_rx_r14_regnum:
 479       val = get_reg (14);
 480       break;
 481     case sim_rx_r15_regnum:
 482       val = get_reg (15);
 483       break;
 484     case sim_rx_isp_regnum:
 485       val = get_reg (isp);
 486       break;
 487     case sim_rx_usp_regnum:
 488       val = get_reg (usp);
 489       break;
 490     case sim_rx_intb_regnum:
 491       val = get_reg (intb);
 492       break;
 493     case sim_rx_pc_regnum:
 494       val = get_reg (pc);
 495       break;
 496     case sim_rx_ps_regnum:
 497       val = get_reg (psw);
 498       break;
 499     case sim_rx_bpc_regnum:
 500       val = get_reg (bpc);
 501       break;
 502     case sim_rx_bpsw_regnum:
 503       val = get_reg (bpsw);
 504       break;
 505     case sim_rx_fintv_regnum:
 506       val = get_reg (fintv);
 507       break;
 508     case sim_rx_fpsw_regnum:
 509       val = get_reg (fpsw);
 510       break;
 511     case sim_rx_acc_regnum:
 512       val = ((DI) get_reg (acchi) << 32) | get_reg (acclo);
 513       break;
 514     default:
 515       fprintf (stderr, "rx minisim: unrecognized register number: %d\n",
 516                regno);
 517       return -1;
 518     }
 519
 520   if (rx_big_endian)
 521     put_be (buf, length, val);
 522   else
 523     put_le (buf, length, val);
 524
 525   return size;
 526 }
 527
 528 int
 529 sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
 530 {
 531   size_t size;
 532   DI val;
 533
 534   check_desc (sd);
 535
 536   if (!check_regno (regno))
 537     return -1;
 538
 539   size = reg_size (regno);
 540
 541   if (length != size)
 542     return -1;
 543
 544   if (rx_big_endian)
 545     val = get_be (buf, length);
 546   else
 547     val = get_le (buf, length);
 548
 549   switch (regno)
 550     {
 551     case sim_rx_r0_regnum:
 552       put_reg (0, val);
 553       break;
 554     case sim_rx_r1_regnum:
 555       put_reg (1, val);
 556       break;
 557     case sim_rx_r2_regnum:
 558       put_reg (2, val);
 559       break;
 560     case sim_rx_r3_regnum:
 561       put_reg (3, val);
 562       break;
 563     case sim_rx_r4_regnum:
 564       put_reg (4, val);
 565       break;
 566     case sim_rx_r5_regnum:
 567       put_reg (5, val);
 568       break;
 569     case sim_rx_r6_regnum:
 570       put_reg (6, val);
 571       break;
 572     case sim_rx_r7_regnum:
 573       put_reg (7, val);
 574       break;
 575     case sim_rx_r8_regnum:
 576       put_reg (8, val);
 577       break;
 578     case sim_rx_r9_regnum:
 579       put_reg (9, val);
 580       break;
 581     case sim_rx_r10_regnum:
 582       put_reg (10, val);
 583       break;
 584     case sim_rx_r11_regnum:
 585       put_reg (11, val);
 586       break;
 587     case sim_rx_r12_regnum:
 588       put_reg (12, val);
 589       break;
 590     case sim_rx_r13_regnum:
 591       put_reg (13, val);
 592       break;
 593     case sim_rx_r14_regnum:
 594       put_reg (14, val);
 595       break;
 596     case sim_rx_r15_regnum:
 597       put_reg (15, val);
 598       break;
 599     case sim_rx_isp_regnum:
 600       put_reg (isp, val);
 601       break;
 602     case sim_rx_usp_regnum:
 603       put_reg (usp, val);
 604       break;
 605     case sim_rx_intb_regnum:
 606       put_reg (intb, val);
 607       break;
 608     case sim_rx_pc_regnum:
 609       put_reg (pc, val);
 610       break;
 611     case sim_rx_ps_regnum:
 612       put_reg (psw, val);
 613       break;
 614     case sim_rx_bpc_regnum:
 615       put_reg (bpc, val);
 616       break;
 617     case sim_rx_bpsw_regnum:
 618       put_reg (bpsw, val);
 619       break;
 620     case sim_rx_fintv_regnum:
 621       put_reg (fintv, val);
 622       break;
 623     case sim_rx_fpsw_regnum:
 624       put_reg (fpsw, val);
 625       break;
 626     case sim_rx_acc_regnum:
 627       put_reg (acclo, val & 0xffffffff);
 628       put_reg (acchi, (val >> 32) & 0xffffffff);
 629       break;
 630     default:
 631       fprintf (stderr, "rx minisim: unrecognized register number: %d\n",
 632                regno);
 633       return 0;
 634     }
 635
 636   return size;
 637 }
 638
 639 void
 640 sim_info (SIM_DESC sd, int verbose)
 641 {
 642   check_desc (sd);
 643
 644   printf ("The rx minisim doesn't collect any statistics.\n");
 645 }
 646
 647 static volatile int stop;
 648 static enum sim_stop reason;
 649 int siggnal;
 650
 651
 652 /* Given a signal number used by the RX bsp (that is, newlib),
 653    return a target signal number used by GDB.  */
 654 static int
 655 rx_signal_to_gdb_signal (int rx)
 656 {
 657   switch (rx)
 658     {
 659     case 4:
 660       return GDB_SIGNAL_ILL;
 661
 662     case 5:
 663       return GDB_SIGNAL_TRAP;
 664
 665     case 10:
 666       return GDB_SIGNAL_BUS;
 667
 668     case 11:
 669       return GDB_SIGNAL_SEGV;
 670
 671     case 24:
 672       return GDB_SIGNAL_XCPU;
 673
 674     case 2:
 675       return GDB_SIGNAL_INT;
 676
 677     case 8:
 678       return GDB_SIGNAL_FPE;
 679
 680     case 6:
 681       return GDB_SIGNAL_ABRT;
 682     }
 683
 684   return 0;
 685 }
 686
 687
 688 /* Take a step return code RC and set up the variables consulted by
 689    sim_stop_reason appropriately.  */
 690 void
 691 handle_step (int rc)
 692 {
 693   if (execution_error_get_last_error () != SIM_ERR_NONE)
 694     {
 695       reason = sim_stopped;
 696       siggnal = GDB_SIGNAL_SEGV;
 697     }
 698   if (RX_STEPPED (rc) || RX_HIT_BREAK (rc))
 699     {
 700       reason = sim_stopped;
 701       siggnal = GDB_SIGNAL_TRAP;
 702     }
 703   else if (RX_STOPPED (rc))
 704     {
 705       reason = sim_stopped;
 706       siggnal = rx_signal_to_gdb_signal (RX_STOP_SIG (rc));
 707     }
 708   else
 709     {
 710       assert (RX_EXITED (rc));
 711       reason = sim_exited;
 712       siggnal = RX_EXIT_STATUS (rc);
 713     }
 714 }
 715
 716
 717 void
 718 sim_resume (SIM_DESC sd, int step, int sig_to_deliver)
 719 {
 720   int rc;
 721
 722   check_desc (sd);
 723
 724   if (sig_to_deliver != 0)
 725     {
 726       fprintf (stderr,
 727                "Warning: the rx minisim does not implement "
 728                "signal delivery yet.\n" "Resuming with no signal.\n");
 729     }
 730
 731   execution_error_clear_last_error ();
 732
 733   if (step)
 734     {
 735       rc = setjmp (decode_jmp_buf);
 736       if (rc == 0)
 737         rc = decode_opcode ();
 738       handle_step (rc);
 739     }
 740   else
 741     {
 742       /* We don't clear 'stop' here, because then we would miss
 743          interrupts that arrived on the way here.  Instead, we clear
 744          the flag in sim_stop_reason, after GDB has disabled the
 745          interrupt signal handler.  */
 746       for (;;)
 747         {
 748           if (stop)
 749             {
 750               stop = 0;
 751               reason = sim_stopped;
 752               siggnal = GDB_SIGNAL_INT;
 753               break;
 754             }
 755
 756           rc = setjmp (decode_jmp_buf);
 757           if (rc == 0)
 758             rc = decode_opcode ();
 759
 760           if (execution_error_get_last_error () != SIM_ERR_NONE)
 761             {
 762               reason = sim_stopped;
 763               siggnal = GDB_SIGNAL_SEGV;
 764               break;
 765             }
 766
 767           if (!RX_STEPPED (rc))
 768             {
 769               handle_step (rc);
 770               break;
 771             }
 772         }
 773     }
 774 }
 775
 776 int
 777 sim_stop (SIM_DESC sd)
 778 {
 779   stop = 1;
 780
 781   return 1;
 782 }
 783
 784 void
 785 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason_p, int *sigrc_p)
 786 {
 787   check_desc (sd);
 788
 789   *reason_p = reason;
 790   *sigrc_p = siggnal;
 791 }
 792
 793 void
 794 sim_do_command (SIM_DESC sd, const char *cmd)
 795 {
 796   const char *args;
 797   char *p = strdup (cmd);
 798
 799   check_desc (sd);
 800
 801   /* Skip leading whitespace.  */
 802   while (isspace (*p))
 803     p++;
 804
 805   /* Find the extent of the command word.  */
 806   for (p = cmd; *p; p++)
 807     if (isspace (*p))
 808       break;
 809
 810   /* Null-terminate the command word, and record the start of any
 811      further arguments.  */
 812   if (*p)
 813     {
 814       *p = '\0';
 815       args = p + 1;
 816       while (isspace (*args))
 817         args++;
 818     }
 819   else
 820     args = p;
 821
 822   if (strcmp (cmd, "trace") == 0)
 823     {
 824       if (strcmp (args, "on") == 0)
 825         trace = 1;
 826       else if (strcmp (args, "off") == 0)
 827         trace = 0;
 828       else
 829         printf ("The 'sim trace' command expects 'on' or 'off' "
 830                 "as an argument.\n");
 831     }
 832   else if (strcmp (cmd, "verbose") == 0)
 833     {
 834       if (strcmp (args, "on") == 0)
 835         verbose = 1;
 836       else if (strcmp (args, "noisy") == 0)
 837         verbose = 2;
 838       else if (strcmp (args, "off") == 0)
 839         verbose = 0;
 840       else
 841         printf ("The 'sim verbose' command expects 'on', 'noisy', or 'off'"
 842                 " as an argument.\n");
 843     }
 844   else
 845     printf ("The 'sim' command expects either 'trace' or 'verbose'"
 846             " as a subcommand.\n");
 847
 848   free (p);
 849 }
 850
 851 char **
 852 sim_complete_command (SIM_DESC sd, const char *text, const char *word)
 853 {
 854   return NULL;
 855 }