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