sim/erc32/interf.c

   1 /*
   2  * This file is part of SIS.
   3  *
   4  * SIS, SPARC instruction simulator V1.6 Copyright (C) 1995 Jiri Gaisler,
   5  * European Space Agency
   6  *
   7  * This program is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 3 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 #include "config.h"
  23 #include <signal.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <time.h>
  28 #include <sys/fcntl.h>
  29 #include "sis.h"
  30 #include "libiberty.h"
  31 #include "bfd.h"
  32 #include <dis-asm.h>
  33 #include "sim-config.h"
  34
  35 #include "gdb/remote-sim.h"
  36 #include "gdb/signals.h"
  37
  38 #define PSR_CWP 0x7
  39
  40 extern struct disassemble_info dinfo;
  41 extern struct pstate sregs;
  42 extern struct estate ebase;
  43
  44 extern int      current_target_byte_order;
  45 extern int      ctrl_c;
  46 extern int      nfp;
  47 extern int      ift;
  48 extern int      rom8;
  49 extern int      wrp;
  50 extern int      uben;
  51 extern int      sis_verbose;
  52 extern char    *sis_version;
  53 extern struct estate ebase;
  54 extern struct evcell evbuf[];
  55 extern struct irqcell irqarr[];
  56 extern int      irqpend, ext_irl;
  57 extern int      sparclite;
  58 extern int      dumbio;
  59 extern int      sparclite_board;
  60 extern int      termsave;
  61 extern char     uart_dev1[], uart_dev2[];
  62
  63 int             sis_gdb_break = 1;
  64
  65 host_callback *sim_callback;
  66
  67 int
  68 run_sim(sregs, icount, dis)
  69     struct pstate  *sregs;
  70     uint64          icount;
  71     int             dis;
  72 {
  73     int             mexc, irq;
  74
  75     if (sis_verbose)
  76         (*sim_callback->printf_filtered) (sim_callback, "resuming at %x\n",
  77                                           sregs->pc);
  78    init_stdio();
  79    sregs->starttime = time(NULL);
  80    irq = 0;
  81    while (!sregs->err_mode & (icount > 0)) {
  82
  83         sregs->fhold = 0;
  84         sregs->hold = 0;
  85         sregs->icnt = 1;
  86
  87         if (sregs->psr & 0x080)
  88             sregs->asi = 8;
  89         else
  90             sregs->asi = 9;
  91
  92 #if 0   /* DELETE ME! for debugging purposes only */
  93         if (sis_verbose > 1)
  94             if (sregs->pc == 0 || sregs->npc == 0)
  95                 printf ("bogus pc or npc\n");
  96 #endif
  97         mexc = memory_read(sregs->asi, sregs->pc, &sregs->inst,
  98                            2, &sregs->hold);
  99 #if 1   /* DELETE ME! for debugging purposes only */
 100         if (sis_verbose > 2)
 101             printf("pc %x, np %x, sp %x, fp %x, wm %x, cw %x, i %08x\n",
 102                    sregs->pc, sregs->npc,
 103                    sregs->r[(((sregs->psr & 7) << 4) + 14) & 0x7f],
 104                    sregs->r[(((sregs->psr & 7) << 4) + 30) & 0x7f],
 105                    sregs->wim,
 106                    sregs->psr & 7,
 107                    sregs->inst);
 108 #endif
 109         if (sregs->annul) {
 110             sregs->annul = 0;
 111             sregs->icnt = 1;
 112             sregs->pc = sregs->npc;
 113             sregs->npc = sregs->npc + 4;
 114         } else {
 115             if (ext_irl) irq = check_interrupts(sregs);
 116             if (!irq) {
 117                 if (mexc) {
 118                     sregs->trap = I_ACC_EXC;
 119                 } else {
 120                     if ((sis_gdb_break) && (sregs->inst == 0x91d02001)) {
 121                         if (sis_verbose)
 122                             (*sim_callback->printf_filtered) (sim_callback,
 123                                                               "SW BP hit at %x\n", sregs->pc);
 124                         sim_halt();
 125                         restore_stdio();
 126                         clearerr(stdin);
 127                         return (BPT_HIT);
 128                     } else
 129                         dispatch_instruction(sregs);
 130                 }
 131                 icount--;
 132             }
 133             if (sregs->trap) {
 134                 irq = 0;
 135                 sregs->err_mode = execute_trap(sregs);
 136             }
 137         }
 138         advance_time(sregs);
 139         if (ctrl_c) {
 140             icount = 0;
 141         }
 142     }
 143     sim_halt();
 144     sregs->tottime += time(NULL) - sregs->starttime;
 145     restore_stdio();
 146     clearerr(stdin);
 147     if (sregs->err_mode)
 148         error_mode(sregs->pc);
 149     if (sregs->err_mode)
 150         return (ERROR);
 151     if (sregs->bphit) {
 152         if (sis_verbose)
 153             (*sim_callback->printf_filtered) (sim_callback,
 154                                               "HW BP hit at %x\n", sregs->pc);
 155         return (BPT_HIT);
 156     }
 157     if (ctrl_c) {
 158         ctrl_c = 0;
 159         return (CTRL_C);
 160     }
 161     return (TIME_OUT);
 162 }
 163
 164 void
 165 sim_set_callbacks (ptr)
 166      host_callback *ptr;
 167 {
 168   sim_callback = ptr;
 169 }
 170
 171 void
 172 sim_size (memsize)
 173      int memsize;
 174 {
 175 }
 176
 177 SIM_DESC
 178 sim_open (kind, callback, abfd, argv)
 179      SIM_OPEN_KIND kind;
 180      struct host_callback_struct *callback;
 181      struct bfd *abfd;
 182      char **argv;
 183 {
 184
 185     int             argc = 0;
 186     int             stat = 1;
 187     int             freq = 0;
 188
 189     sim_callback = callback;
 190
 191     while (argv[argc])
 192       argc++;
 193     while (stat < argc) {
 194         if (argv[stat][0] == '-') {
 195             if (strcmp(argv[stat], "-v") == 0) {
 196                 sis_verbose++;
 197             } else
 198             if (strcmp(argv[stat], "-nfp") == 0) {
 199                 nfp = 1;
 200             } else
 201             if (strcmp(argv[stat], "-ift") == 0) {
 202                 ift = 1;
 203             } else
 204             if (strcmp(argv[stat], "-sparclite") == 0) {
 205                 sparclite = 1;
 206             } else
 207             if (strcmp(argv[stat], "-sparclite-board") == 0) {
 208                 sparclite_board = 1;
 209             } else
 210             if (strcmp(argv[stat], "-dumbio") == 0) {
 211                 dumbio = 1;
 212             } else
 213             if (strcmp(argv[stat], "-wrp") == 0) {
 214                 wrp = 1;
 215             } else
 216             if (strcmp(argv[stat], "-rom8") == 0) {
 217                 rom8 = 1;
 218             } else
 219             if (strcmp(argv[stat], "-uben") == 0) {
 220                 uben = 1;
 221             } else
 222             if (strcmp(argv[stat], "-uart1") == 0) {
 223                 if ((stat + 1) < argc)
 224                     strcpy(uart_dev1, argv[++stat]);
 225             } else
 226             if (strcmp(argv[stat], "-uart2") == 0) {
 227                 if ((stat + 1) < argc)
 228                     strcpy(uart_dev2, argv[++stat]);
 229             } else
 230             if (strcmp(argv[stat], "-nogdb") == 0) {
 231                 sis_gdb_break = 0;
 232             } else
 233             if (strcmp(argv[stat], "-freq") == 0) {
 234                 if ((stat + 1) < argc) {
 235                     freq = strtol(argv[++stat], (char **)NULL, 0);
 236                 }
 237             } else
 238             if (strncmp(argv[stat], "--sysroot=", sizeof("--sysroot=") - 1) == 0) {
 239                 /* Ignore until we start to support this.  */
 240             } else {
 241                 (*sim_callback->printf_filtered) (sim_callback,
 242                                                   "unknown option %s\n",
 243                                                   argv[stat]);
 244             }
 245         } else
 246             bfd_load(argv[stat]);
 247         stat++;
 248     }
 249
 250     if (sis_verbose) {
 251         (*sim_callback->printf_filtered) (sim_callback, "\n SIS - SPARC instruction simulator %s\n", sis_version);
 252         (*sim_callback->printf_filtered) (sim_callback, " Bug-reports to Jiri Gaisler ESA/ESTEC ([email protected])\n");
 253         if (nfp)
 254           (*sim_callback->printf_filtered) (sim_callback, "no FPU\n");
 255         if (sparclite)
 256           (*sim_callback->printf_filtered) (sim_callback, "simulating Sparclite\n");
 257         if (dumbio)
 258           (*sim_callback->printf_filtered) (sim_callback, "dumb IO (no input, dumb output)\n");
 259         if (sis_gdb_break == 0)
 260           (*sim_callback->printf_filtered) (sim_callback, "disabling GDB trap handling for breakpoints\n");
 261         if (freq)
 262           (*sim_callback->printf_filtered) (sim_callback, " ERC32 freq %d Mhz\n", freq);
 263     }
 264
 265     sregs.freq = freq ? freq : 15;
 266     termsave = fcntl(0, F_GETFL, 0);
 267     INIT_DISASSEMBLE_INFO(dinfo, stdout,(fprintf_ftype)fprintf);
 268     dinfo.endian = BFD_ENDIAN_BIG;
 269     reset_all();
 270     ebase.simtime = 0;
 271     init_sim();
 272     init_bpt(&sregs);
 273     reset_stat(&sregs);
 274
 275     /* Fudge our descriptor for now.  */
 276     return (SIM_DESC) 1;
 277 }
 278
 279 void
 280 sim_close(sd, quitting)
 281      SIM_DESC sd;
 282      int quitting;
 283 {
 284
 285     exit_sim();
 286     fcntl(0, F_SETFL, termsave);
 287
 288 };
 289
 290 SIM_RC
 291 sim_load(sd, prog, abfd, from_tty)
 292      SIM_DESC sd;
 293      const char *prog;
 294      bfd *abfd;
 295      int from_tty;
 296 {
 297     bfd_load (prog);
 298     return SIM_RC_OK;
 299 }
 300
 301 SIM_RC
 302 sim_create_inferior(sd, abfd, argv, env)
 303      SIM_DESC sd;
 304      struct bfd *abfd;
 305      char **argv;
 306      char **env;
 307 {
 308     bfd_vma start_address = 0;
 309     if (abfd != NULL)
 310       start_address = bfd_get_start_address (abfd);
 311
 312     ebase.simtime = 0;
 313     reset_all();
 314     reset_stat(&sregs);
 315     sregs.pc = start_address & ~3;
 316     sregs.npc = sregs.pc + 4;
 317     return SIM_RC_OK;
 318 }
 319
 320 int
 321 sim_store_register(sd, regno, value, length)
 322     SIM_DESC sd;
 323     int             regno;
 324     unsigned char  *value;
 325     int length;
 326 {
 327     /* FIXME: Review the computation of regval.  */
 328     int regval;
 329     if (current_target_byte_order == BIG_ENDIAN)
 330         regval = (value[0] << 24) | (value[1] << 16)
 331                  | (value[2] << 8) | value[3];
 332     else
 333         regval = (value[3] << 24) | (value[2] << 16)
 334                  | (value[1] << 8) | value[0];
 335     set_regi(&sregs, regno, regval);
 336     return length;
 337 }
 338
 339
 340 int
 341 sim_fetch_register(sd, regno, buf, length)
 342      SIM_DESC sd;
 343     int             regno;
 344     unsigned char  *buf;
 345      int length;
 346 {
 347     get_regi(&sregs, regno, buf);
 348     return -1;
 349 }
 350
 351 int
 352 sim_write(sd, mem, buf, length)
 353      SIM_DESC sd;
 354     SIM_ADDR             mem;
 355     const unsigned char  *buf;
 356     int             length;
 357 {
 358     return (sis_memory_write(mem, buf, length));
 359 }
 360
 361 int
 362 sim_read(sd, mem, buf, length)
 363      SIM_DESC sd;
 364      SIM_ADDR mem;
 365      unsigned char *buf;
 366      int length;
 367 {
 368     return (sis_memory_read(mem, buf, length));
 369 }
 370
 371 void
 372 sim_info(sd, verbose)
 373      SIM_DESC sd;
 374      int verbose;
 375 {
 376     show_stat(&sregs);
 377 }
 378
 379 int             simstat = OK;
 380
 381 void
 382 sim_stop_reason(sd, reason, sigrc)
 383      SIM_DESC sd;
 384      enum sim_stop * reason;
 385      int *sigrc;
 386 {
 387
 388     switch (simstat) {
 389         case CTRL_C:
 390         *reason = sim_stopped;
 391         *sigrc = GDB_SIGNAL_INT;
 392         break;
 393     case OK:
 394     case TIME_OUT:
 395     case BPT_HIT:
 396         *reason = sim_stopped;
 397         *sigrc = GDB_SIGNAL_TRAP;
 398         break;
 399     case ERROR:
 400         *sigrc = 0;
 401         *reason = sim_exited;
 402     }
 403     ctrl_c = 0;
 404     simstat = OK;
 405 }
 406
 407 /* Flush all register windows out to the stack.  Starting after the invalid
 408    window, flush all windows up to, and including the current window.  This
 409    allows GDB to do backtraces and look at local variables for frames that
 410    are still in the register windows.  Note that strictly speaking, this
 411    behavior is *wrong* for several reasons.  First, it doesn't use the window
 412    overflow handlers.  It therefore assumes standard frame layouts and window
 413    handling policies.  Second, it changes system state behind the back of the
 414    target program.  I expect this to mainly pose problems when debugging trap
 415    handlers.
 416 */
 417
 418 static void
 419 flush_windows ()
 420 {
 421   int invwin;
 422   int cwp;
 423   int win;
 424   int ws;
 425
 426   /* Keep current window handy */
 427
 428   cwp = sregs.psr & PSR_CWP;
 429
 430   /* Calculate the invalid window from the wim. */
 431
 432   for (invwin = 0; invwin <= PSR_CWP; invwin++)
 433     if ((sregs.wim >> invwin) & 1)
 434       break;
 435
 436   /* Start saving with the window after the invalid window. */
 437
 438   invwin = (invwin - 1) & PSR_CWP;
 439
 440   for (win = invwin; ; win = (win - 1) & PSR_CWP)
 441     {
 442       uint32 sp;
 443       int i;
 444
 445       sp = sregs.r[(win * 16 + 14) & 0x7f];
 446 #if 1
 447       if (sis_verbose > 2) {
 448         uint32 fp = sregs.r[(win * 16 + 30) & 0x7f];
 449         printf("flush_window: win %d, sp %x, fp %x\n", win, sp, fp);
 450       }
 451 #endif
 452
 453       for (i = 0; i < 16; i++)
 454         memory_write (11, sp + 4 * i, &sregs.r[(win * 16 + 16 + i) & 0x7f], 2,
 455                       &ws);
 456
 457       if (win == cwp)
 458         break;
 459     }
 460 }
 461
 462 void
 463 sim_resume(SIM_DESC sd, int step, int siggnal)
 464 {
 465     simstat = run_sim(&sregs, UINT64_MAX, 0);
 466
 467     if (sis_gdb_break) flush_windows ();
 468 }
 469
 470 int
 471 sim_trace (sd)
 472      SIM_DESC sd;
 473 {
 474   /* FIXME: unfinished */
 475   sim_resume (sd, 0, 0);
 476   return 1;
 477 }
 478
 479 void
 480 sim_do_command(sd, cmd)
 481      SIM_DESC sd;
 482      const char *cmd;
 483 {
 484     exec_cmd(&sregs, cmd);
 485 }
 486
 487 char **
 488 sim_complete_command (SIM_DESC sd, const char *text, const char *word)
 489 {
 490   return NULL;
 491 }
 492
 493 #if 0 /* FIXME: These shouldn't exist.  */
 494
 495 int
 496 sim_insert_breakpoint(int addr)
 497 {
 498     if (sregs.bptnum < BPT_MAX) {
 499         sregs.bpts[sregs.bptnum] = addr & ~0x3;
 500         sregs.bptnum++;
 501         if (sis_verbose)
 502             (*sim_callback->printf_filtered) (sim_callback, "inserted HW BP at %x\n", addr);
 503         return 0;
 504     } else
 505         return 1;
 506 }
 507
 508 int
 509 sim_remove_breakpoint(int addr)
 510 {
 511     int             i = 0;
 512
 513     while ((i < sregs.bptnum) && (sregs.bpts[i] != addr))
 514         i++;
 515     if (addr == sregs.bpts[i]) {
 516         for (; i < sregs.bptnum - 1; i++)
 517             sregs.bpts[i] = sregs.bpts[i + 1];
 518         sregs.bptnum -= 1;
 519         if (sis_verbose)
 520             (*sim_callback->printf_filtered) (sim_callback, "removed HW BP at %x\n", addr);
 521         return 0;
 522     }
 523     return 1;
 524 }
 525
 526 #endif