sim/rl78/gdb-if.c

   1 /* gdb-if.c -- sim interface to GDB.
   2
   3 Copyright (C) 2011-2019 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-rl78.h"
  34
  35 #include "cpu.h"
  36 #include "mem.h"
  37 #include "load.h"
  38 #include "trace.h"
  39
  40 /* Ideally, we'd wrap up all the minisim's data structures in an
  41    object and pass that around.  However, neither GDB nor run needs
  42    that ability.
  43
  44    So we just have one instance, that lives in global variables, and
  45    each time we open it, we re-initialize it.  */
  46
  47 struct sim_state
  48 {
  49   const char *message;
  50 };
  51
  52 static struct sim_state the_minisim = {
  53   "This is the sole rl78 minisim instance."
  54 };
  55
  56 static int open;
  57
  58 static struct host_callback_struct *host_callbacks;
  59
  60 /* Open an instance of the sim.  For this sim, only one instance
  61    is permitted.  If sim_open() is called multiple times, the sim
  62    will be reset.  */
  63
  64 SIM_DESC
  65 sim_open (SIM_OPEN_KIND kind,
  66           struct host_callback_struct *callback,
  67           struct bfd *abfd, char * const *argv)
  68 {
  69   if (open)
  70     fprintf (stderr, "rl78 minisim: re-opened sim\n");
  71
  72   /* The 'run' interface doesn't use this function, so we don't care
  73      about KIND; it's always SIM_OPEN_DEBUG.  */
  74   if (kind != SIM_OPEN_DEBUG)
  75     fprintf (stderr, "rl78 minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
  76              kind);
  77
  78   /* We use this for the load command.  Perhaps someday, it'll be used
  79      for syscalls too.  */
  80   host_callbacks = callback;
  81
  82   /* We don't expect any command-line arguments.  */
  83
  84   init_cpu ();
  85   trace = 0;
  86
  87   sim_disasm_init (abfd);
  88   open = 1;
  89
  90   while (argv != NULL && *argv != NULL)
  91     {
  92       if (strcmp (*argv, "g10") == 0 || strcmp (*argv, "-Mg10") == 0)
  93         {
  94           fprintf (stderr, "rl78 g10 support enabled.\n");
  95           rl78_g10_mode = 1;
  96           g13_multiply = 0;
  97           g14_multiply = 0;
  98           mem_set_mirror (0, 0xf8000, 4096);
  99           break;
 100         }
 101       if (strcmp (*argv, "g13") == 0 || strcmp (*argv, "-Mg13") == 0)
 102         {
 103           fprintf (stderr, "rl78 g13 support enabled.\n");
 104           rl78_g10_mode = 0;
 105           g13_multiply = 1;
 106           g14_multiply = 0;
 107           break;
 108         }
 109       if (strcmp (*argv, "g14") == 0 || strcmp (*argv, "-Mg14") == 0)
 110         {
 111           fprintf (stderr, "rl78 g14 support enabled.\n");
 112           rl78_g10_mode = 0;
 113           g13_multiply = 0;
 114           g14_multiply = 1;
 115           break;
 116         }
 117       argv++;
 118     }
 119
 120   return &the_minisim;
 121 }
 122
 123 /* Verify the sim descriptor.  Just print a message if the descriptor
 124    doesn't match.  Nothing bad will happen if the descriptor doesn't
 125    match because all of the state is global.  But if it doesn't
 126    match, that means there's a problem with the caller.  */
 127
 128 static void
 129 check_desc (SIM_DESC sd)
 130 {
 131   if (sd != &the_minisim)
 132     fprintf (stderr, "rl78 minisim: desc != &the_minisim\n");
 133 }
 134
 135 /* Close the sim.  */
 136
 137 void
 138 sim_close (SIM_DESC sd, int quitting)
 139 {
 140   check_desc (sd);
 141
 142   /* Not much to do.  At least free up our memory.  */
 143   init_mem ();
 144
 145   open = 0;
 146 }
 147
 148 /* Open the program to run; print a message if the program cannot
 149    be opened.  */
 150
 151 static bfd *
 152 open_objfile (const char *filename)
 153 {
 154   bfd *prog = bfd_openr (filename, 0);
 155
 156   if (!prog)
 157     {
 158       fprintf (stderr, "Can't read %s\n", filename);
 159       return 0;
 160     }
 161
 162   if (!bfd_check_format (prog, bfd_object))
 163     {
 164       fprintf (stderr, "%s not a rl78 program\n", filename);
 165       return 0;
 166     }
 167
 168   return prog;
 169 }
 170
 171 /* Load a program.  */
 172
 173 SIM_RC
 174 sim_load (SIM_DESC sd, const char *prog, struct bfd *abfd, int from_tty)
 175 {
 176   check_desc (sd);
 177
 178   if (!abfd)
 179     abfd = open_objfile (prog);
 180   if (!abfd)
 181     return SIM_RC_FAIL;
 182
 183   rl78_load (abfd, host_callbacks, "sim");
 184
 185   return SIM_RC_OK;
 186 }
 187
 188 /* Create inferior.  */
 189
 190 SIM_RC
 191 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
 192                      char * const *argv, char * const *env)
 193 {
 194   check_desc (sd);
 195
 196   if (abfd)
 197     rl78_load (abfd, 0, "sim");
 198
 199   return SIM_RC_OK;
 200 }
 201
 202 /* Read memory.  */
 203
 204 int
 205 sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
 206 {
 207   check_desc (sd);
 208
 209   if (mem >= MEM_SIZE)
 210     return 0;
 211   else if (mem + length > MEM_SIZE)
 212     length = MEM_SIZE - mem;
 213
 214   mem_get_blk (mem, buf, length);
 215   return length;
 216 }
 217
 218 /* Write memory.  */
 219
 220 int
 221 sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length)
 222 {
 223   check_desc (sd);
 224
 225   if (mem >= MEM_SIZE)
 226     return 0;
 227   else if (mem + length > MEM_SIZE)
 228     length = MEM_SIZE - mem;
 229
 230   mem_put_blk (mem, buf, length);
 231   return length;
 232 }
 233
 234 /* Read the LENGTH bytes at BUF as an little-endian value.  */
 235
 236 static SI
 237 get_le (unsigned char *buf, int length)
 238 {
 239   SI acc = 0;
 240
 241   while (--length >= 0)
 242     acc = (acc << 8) + buf[length];
 243
 244   return acc;
 245 }
 246
 247 /* Store VAL as a little-endian value in the LENGTH bytes at BUF.  */
 248
 249 static void
 250 put_le (unsigned char *buf, int length, SI val)
 251 {
 252   int i;
 253
 254   for (i = 0; i < length; i++)
 255     {
 256       buf[i] = val & 0xff;
 257       val >>= 8;
 258     }
 259 }
 260
 261 /* Verify that REGNO is in the proper range.  Return 0 if not and
 262    something non-zero if so.  */
 263
 264 static int
 265 check_regno (enum sim_rl78_regnum regno)
 266 {
 267   return 0 <= regno && regno < sim_rl78_num_regs;
 268 }
 269
 270 /* Return the size of the register REGNO.  */
 271
 272 static size_t
 273 reg_size (enum sim_rl78_regnum regno)
 274 {
 275   size_t size;
 276
 277   if (regno == sim_rl78_pc_regnum)
 278     size = 4;
 279   else
 280     size = 1;
 281
 282   return size;
 283 }
 284
 285 /* Return the register address associated with the register specified by
 286    REGNO.  */
 287
 288 static unsigned long
 289 reg_addr (enum sim_rl78_regnum regno)
 290 {
 291   if (sim_rl78_bank0_r0_regnum <= regno
 292       && regno <= sim_rl78_bank0_r7_regnum)
 293     return 0xffef8 + (regno - sim_rl78_bank0_r0_regnum);
 294   else if (sim_rl78_bank1_r0_regnum <= regno
 295            && regno <= sim_rl78_bank1_r7_regnum)
 296     return 0xffef0 + (regno - sim_rl78_bank1_r0_regnum);
 297   else if (sim_rl78_bank2_r0_regnum <= regno
 298            && regno <= sim_rl78_bank2_r7_regnum)
 299     return 0xffee8 + (regno - sim_rl78_bank2_r0_regnum);
 300   else if (sim_rl78_bank3_r0_regnum <= regno
 301            && regno <= sim_rl78_bank3_r7_regnum)
 302     return 0xffee0 + (regno - sim_rl78_bank3_r0_regnum);
 303   else if (regno == sim_rl78_psw_regnum)
 304     return 0xffffa;
 305   else if (regno == sim_rl78_es_regnum)
 306     return 0xffffd;
 307   else if (regno == sim_rl78_cs_regnum)
 308     return 0xffffc;
 309   /* Note: We can't handle PC here because it's not memory mapped.  */
 310   else if (regno == sim_rl78_spl_regnum)
 311     return 0xffff8;
 312   else if (regno == sim_rl78_sph_regnum)
 313     return 0xffff9;
 314   else if (regno == sim_rl78_pmc_regnum)
 315     return 0xffffe;
 316   else if (regno == sim_rl78_mem_regnum)
 317     return 0xfffff;
 318
 319   return 0;
 320 }
 321
 322 /* Fetch the contents of the register specified by REGNO, placing the
 323    contents in BUF.  The length LENGTH must match the sim's internal
 324    notion of the register's size.  */
 325
 326 int
 327 sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
 328 {
 329   size_t size;
 330   SI val;
 331
 332   check_desc (sd);
 333
 334   if (!check_regno (regno))
 335     return 0;
 336
 337   size = reg_size (regno);
 338
 339   if (length != size)
 340     return 0;
 341
 342   if (regno == sim_rl78_pc_regnum)
 343     val = pc;
 344   else
 345     val = memory[reg_addr (regno)];
 346
 347   put_le (buf, length, val);
 348
 349   return size;
 350 }
 351
 352 /* Store the value stored in BUF to the register REGNO.  The length
 353    LENGTH must match the sim's internal notion of the register size.  */
 354
 355 int
 356 sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
 357 {
 358   size_t size;
 359   SI val;
 360
 361   check_desc (sd);
 362
 363   if (!check_regno (regno))
 364     return -1;
 365
 366   size = reg_size (regno);
 367
 368   if (length != size)
 369     return -1;
 370
 371   val = get_le (buf, length);
 372
 373   if (regno == sim_rl78_pc_regnum)
 374     {
 375       pc = val;
 376
 377       /* The rl78 program counter is 20 bits wide.  Ensure that GDB
 378          hasn't picked up any stray bits.  This has occurred when performing
 379          a GDB "return" command in which the return address is obtained
 380          from a 32-bit container on the stack.  */
 381       assert ((pc & ~0x0fffff) == 0);
 382     }
 383   else
 384     memory[reg_addr (regno)] = val;
 385   return size;
 386 }
 387
 388 /* Print out message associated with "info target".  */
 389
 390 void
 391 sim_info (SIM_DESC sd, int verbose)
 392 {
 393   check_desc (sd);
 394
 395   printf ("The rl78 minisim doesn't collect any statistics.\n");
 396 }
 397
 398 static volatile int stop;
 399 static enum sim_stop reason;
 400 int siggnal;
 401
 402
 403 /* Given a signal number used by the rl78 bsp (that is, newlib),
 404    return the corresponding signal numbers.  */
 405
 406 int
 407 rl78_signal_to_target (int sig)
 408 {
 409   switch (sig)
 410     {
 411     case 4:
 412       return GDB_SIGNAL_ILL;
 413
 414     case 5:
 415       return GDB_SIGNAL_TRAP;
 416
 417     case 10:
 418       return GDB_SIGNAL_BUS;
 419
 420     case 11:
 421       return GDB_SIGNAL_SEGV;
 422
 423     case 24:
 424       return GDB_SIGNAL_XCPU;
 425       break;
 426
 427     case 2:
 428       return GDB_SIGNAL_INT;
 429
 430     case 8:
 431       return GDB_SIGNAL_FPE;
 432       break;
 433
 434     case 6:
 435       return GDB_SIGNAL_ABRT;
 436     }
 437
 438   return 0;
 439 }
 440
 441
 442 /* Take a step return code RC and set up the variables consulted by
 443    sim_stop_reason appropriately.  */
 444
 445 void
 446 handle_step (int rc)
 447 {
 448   if (RL78_STEPPED (rc) || RL78_HIT_BREAK (rc))
 449     {
 450       reason = sim_stopped;
 451       siggnal = GDB_SIGNAL_TRAP;
 452     }
 453   else if (RL78_STOPPED (rc))
 454     {
 455       reason = sim_stopped;
 456       siggnal = rl78_signal_to_target (RL78_STOP_SIG (rc));
 457     }
 458   else
 459     {
 460       assert (RL78_EXITED (rc));
 461       reason = sim_exited;
 462       siggnal = RL78_EXIT_STATUS (rc);
 463     }
 464 }
 465
 466
 467 /* Resume execution after a stop.  */
 468
 469 void
 470 sim_resume (SIM_DESC sd, int step, int sig_to_deliver)
 471 {
 472   int rc;
 473
 474   check_desc (sd);
 475
 476   if (sig_to_deliver != 0)
 477     {
 478       fprintf (stderr,
 479                "Warning: the rl78 minisim does not implement "
 480                "signal delivery yet.\n" "Resuming with no signal.\n");
 481     }
 482
 483       /* We don't clear 'stop' here, because then we would miss
 484          interrupts that arrived on the way here.  Instead, we clear
 485          the flag in sim_stop_reason, after GDB has disabled the
 486          interrupt signal handler.  */
 487   for (;;)
 488     {
 489       if (stop)
 490         {
 491           stop = 0;
 492           reason = sim_stopped;
 493           siggnal = GDB_SIGNAL_INT;
 494           break;
 495         }
 496
 497       rc = setjmp (decode_jmp_buf);
 498       if (rc == 0)
 499         rc = decode_opcode ();
 500
 501       if (!RL78_STEPPED (rc) || step)
 502         {
 503           handle_step (rc);
 504           break;
 505         }
 506     }
 507 }
 508
 509 /* Stop the sim.  */
 510
 511 int
 512 sim_stop (SIM_DESC sd)
 513 {
 514   stop = 1;
 515
 516   return 1;
 517 }
 518
 519 /* Fetch the stop reason and signal.  */
 520
 521 void
 522 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason_p, int *sigrc_p)
 523 {
 524   check_desc (sd);
 525
 526   *reason_p = reason;
 527   *sigrc_p = siggnal;
 528 }
 529
 530 /* Execute the sim-specific command associated with GDB's "sim ..."
 531    command.  */
 532
 533 void
 534 sim_do_command (SIM_DESC sd, const char *cmd)
 535 {
 536   const char *args;
 537   char *p = strdup (cmd);
 538
 539   check_desc (sd);
 540
 541   if (cmd == NULL)
 542     {
 543       cmd = "";
 544       args = "";
 545     }
 546   else
 547     {
 548       /* Skip leading whitespace.  */
 549       while (isspace (*p))
 550         p++;
 551
 552       /* Find the extent of the command word.  */
 553       for (p = cmd; *p; p++)
 554         if (isspace (*p))
 555           break;
 556
 557       /* Null-terminate the command word, and record the start of any
 558          further arguments.  */
 559       if (*p)
 560         {
 561           *p = '\0';
 562           args = p + 1;
 563           while (isspace (*args))
 564             args++;
 565         }
 566       else
 567         args = p;
 568     }
 569
 570   if (strcmp (cmd, "trace") == 0)
 571     {
 572       if (strcmp (args, "on") == 0)
 573         trace = 1;
 574       else if (strcmp (args, "off") == 0)
 575         trace = 0;
 576       else
 577         printf ("The 'sim trace' command expects 'on' or 'off' "
 578                 "as an argument.\n");
 579     }
 580   else if (strcmp (cmd, "verbose") == 0)
 581     {
 582       if (strcmp (args, "on") == 0)
 583         verbose = 1;
 584       else if (strcmp (args, "noisy") == 0)
 585         verbose = 2;
 586       else if (strcmp (args, "off") == 0)
 587         verbose = 0;
 588       else
 589         printf ("The 'sim verbose' command expects 'on', 'noisy', or 'off'"
 590                 " as an argument.\n");
 591     }
 592   else
 593     printf ("The 'sim' command expects either 'trace' or 'verbose'"
 594             " as a subcommand.\n");
 595
 596   free (p);
 597 }
 598
 599 /* Stub for command completion.  */
 600
 601 char **
 602 sim_complete_command (SIM_DESC sd, const char *text, const char *word)
 603 {
 604     return NULL;
 605 }