1 /* gdb-if.c -- sim interface to GDB. 2 3 Copyright (C) 2011-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-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 **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, char **argv, char **env) 192 { 193 check_desc (sd); 194 195 if (abfd) 196 rl78_load (abfd, 0, "sim"); 197 198 return SIM_RC_OK; 199 } 200 201 /* Read memory. */ 202 203 int 204 sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length) 205 { 206 check_desc (sd); 207 208 if (mem >= MEM_SIZE) 209 return 0; 210 else if (mem + length > MEM_SIZE) 211 length = MEM_SIZE - mem; 212 213 mem_get_blk (mem, buf, length); 214 return length; 215 } 216 217 /* Write memory. */ 218 219 int 220 sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length) 221 { 222 check_desc (sd); 223 224 if (mem >= MEM_SIZE) 225 return 0; 226 else if (mem + length > MEM_SIZE) 227 length = MEM_SIZE - mem; 228 229 mem_put_blk (mem, buf, length); 230 return length; 231 } 232 233 /* Read the LENGTH bytes at BUF as an little-endian value. */ 234 235 static SI 236 get_le (unsigned char *buf, int length) 237 { 238 SI acc = 0; 239 240 while (--length >= 0) 241 acc = (acc << 8) + buf[length]; 242 243 return acc; 244 } 245 246 /* Store VAL as a little-endian value in the LENGTH bytes at BUF. */ 247 248 static void 249 put_le (unsigned char *buf, int length, SI val) 250 { 251 int i; 252 253 for (i = 0; i < length; i++) 254 { 255 buf[i] = val & 0xff; 256 val >>= 8; 257 } 258 } 259 260 /* Verify that REGNO is in the proper range. Return 0 if not and 261 something non-zero if so. */ 262 263 static int 264 check_regno (enum sim_rl78_regnum regno) 265 { 266 return 0 <= regno && regno < sim_rl78_num_regs; 267 } 268 269 /* Return the size of the register REGNO. */ 270 271 static size_t 272 reg_size (enum sim_rl78_regnum regno) 273 { 274 size_t size; 275 276 if (regno == sim_rl78_pc_regnum) 277 size = 4; 278 else 279 size = 1; 280 281 return size; 282 } 283 284 /* Return the register address associated with the register specified by 285 REGNO. */ 286 287 static unsigned long 288 reg_addr (enum sim_rl78_regnum regno) 289 { 290 if (sim_rl78_bank0_r0_regnum <= regno 291 && regno <= sim_rl78_bank0_r7_regnum) 292 return 0xffef8 + (regno - sim_rl78_bank0_r0_regnum); 293 else if (sim_rl78_bank1_r0_regnum <= regno 294 && regno <= sim_rl78_bank1_r7_regnum) 295 return 0xffef0 + (regno - sim_rl78_bank1_r0_regnum); 296 else if (sim_rl78_bank2_r0_regnum <= regno 297 && regno <= sim_rl78_bank2_r7_regnum) 298 return 0xffee8 + (regno - sim_rl78_bank2_r0_regnum); 299 else if (sim_rl78_bank3_r0_regnum <= regno 300 && regno <= sim_rl78_bank3_r7_regnum) 301 return 0xffee0 + (regno - sim_rl78_bank3_r0_regnum); 302 else if (regno == sim_rl78_psw_regnum) 303 return 0xffffa; 304 else if (regno == sim_rl78_es_regnum) 305 return 0xffffd; 306 else if (regno == sim_rl78_cs_regnum) 307 return 0xffffc; 308 /* Note: We can't handle PC here because it's not memory mapped. */ 309 else if (regno == sim_rl78_spl_regnum) 310 return 0xffff8; 311 else if (regno == sim_rl78_sph_regnum) 312 return 0xffff9; 313 else if (regno == sim_rl78_pmc_regnum) 314 return 0xffffe; 315 else if (regno == sim_rl78_mem_regnum) 316 return 0xfffff; 317 318 return 0; 319 } 320 321 /* Fetch the contents of the register specified by REGNO, placing the 322 contents in BUF. The length LENGTH must match the sim's internal 323 notion of the register's size. */ 324 325 int 326 sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length) 327 { 328 size_t size; 329 SI val; 330 331 check_desc (sd); 332 333 if (!check_regno (regno)) 334 return 0; 335 336 size = reg_size (regno); 337 338 if (length != size) 339 return 0; 340 341 if (regno == sim_rl78_pc_regnum) 342 val = pc; 343 else 344 val = memory[reg_addr (regno)]; 345 346 put_le (buf, length, val); 347 348 return size; 349 } 350 351 /* Store the value stored in BUF to the register REGNO. The length 352 LENGTH must match the sim's internal notion of the register size. */ 353 354 int 355 sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length) 356 { 357 size_t size; 358 SI val; 359 360 check_desc (sd); 361 362 if (!check_regno (regno)) 363 return -1; 364 365 size = reg_size (regno); 366 367 if (length != size) 368 return -1; 369 370 val = get_le (buf, length); 371 372 if (regno == sim_rl78_pc_regnum) 373 { 374 pc = val; 375 376 /* The rl78 program counter is 20 bits wide. Ensure that GDB 377 hasn't picked up any stray bits. This has occurred when performing 378 a GDB "return" command in which the return address is obtained 379 from a 32-bit container on the stack. */ 380 assert ((pc & ~0x0fffff) == 0); 381 } 382 else 383 memory[reg_addr (regno)] = val; 384 return size; 385 } 386 387 /* Print out message associated with "info target". */ 388 389 void 390 sim_info (SIM_DESC sd, int verbose) 391 { 392 check_desc (sd); 393 394 printf ("The rl78 minisim doesn't collect any statistics.\n"); 395 } 396 397 static volatile int stop; 398 static enum sim_stop reason; 399 int siggnal; 400 401 402 /* Given a signal number used by the rl78 bsp (that is, newlib), 403 return the corresponding signal numbers. */ 404 405 int 406 rl78_signal_to_target (int sig) 407 { 408 switch (sig) 409 { 410 case 4: 411 return GDB_SIGNAL_ILL; 412 413 case 5: 414 return GDB_SIGNAL_TRAP; 415 416 case 10: 417 return GDB_SIGNAL_BUS; 418 419 case 11: 420 return GDB_SIGNAL_SEGV; 421 422 case 24: 423 return GDB_SIGNAL_XCPU; 424 break; 425 426 case 2: 427 return GDB_SIGNAL_INT; 428 429 case 8: 430 return GDB_SIGNAL_FPE; 431 break; 432 433 case 6: 434 return GDB_SIGNAL_ABRT; 435 } 436 437 return 0; 438 } 439 440 441 /* Take a step return code RC and set up the variables consulted by 442 sim_stop_reason appropriately. */ 443 444 void 445 handle_step (int rc) 446 { 447 if (RL78_STEPPED (rc) || RL78_HIT_BREAK (rc)) 448 { 449 reason = sim_stopped; 450 siggnal = GDB_SIGNAL_TRAP; 451 } 452 else if (RL78_STOPPED (rc)) 453 { 454 reason = sim_stopped; 455 siggnal = rl78_signal_to_target (RL78_STOP_SIG (rc)); 456 } 457 else 458 { 459 assert (RL78_EXITED (rc)); 460 reason = sim_exited; 461 siggnal = RL78_EXIT_STATUS (rc); 462 } 463 } 464 465 466 /* Resume execution after a stop. */ 467 468 void 469 sim_resume (SIM_DESC sd, int step, int sig_to_deliver) 470 { 471 int rc; 472 473 check_desc (sd); 474 475 if (sig_to_deliver != 0) 476 { 477 fprintf (stderr, 478 "Warning: the rl78 minisim does not implement " 479 "signal delivery yet.\n" "Resuming with no signal.\n"); 480 } 481 482 /* We don't clear 'stop' here, because then we would miss 483 interrupts that arrived on the way here. Instead, we clear 484 the flag in sim_stop_reason, after GDB has disabled the 485 interrupt signal handler. */ 486 for (;;) 487 { 488 if (stop) 489 { 490 stop = 0; 491 reason = sim_stopped; 492 siggnal = GDB_SIGNAL_INT; 493 break; 494 } 495 496 rc = setjmp (decode_jmp_buf); 497 if (rc == 0) 498 rc = decode_opcode (); 499 500 if (!RL78_STEPPED (rc) || step) 501 { 502 handle_step (rc); 503 break; 504 } 505 } 506 } 507 508 /* Stop the sim. */ 509 510 int 511 sim_stop (SIM_DESC sd) 512 { 513 stop = 1; 514 515 return 1; 516 } 517 518 /* Fetch the stop reason and signal. */ 519 520 void 521 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason_p, int *sigrc_p) 522 { 523 check_desc (sd); 524 525 *reason_p = reason; 526 *sigrc_p = siggnal; 527 } 528 529 /* Execute the sim-specific command associated with GDB's "sim ..." 530 command. */ 531 532 void 533 sim_do_command (SIM_DESC sd, const char *cmd) 534 { 535 const char *args; 536 char *p = strdup (cmd); 537 538 check_desc (sd); 539 540 if (cmd == NULL) 541 { 542 cmd = ""; 543 args = ""; 544 } 545 else 546 { 547 /* Skip leading whitespace. */ 548 while (isspace (*p)) 549 p++; 550 551 /* Find the extent of the command word. */ 552 for (p = cmd; *p; p++) 553 if (isspace (*p)) 554 break; 555 556 /* Null-terminate the command word, and record the start of any 557 further arguments. */ 558 if (*p) 559 { 560 *p = '\0'; 561 args = p + 1; 562 while (isspace (*args)) 563 args++; 564 } 565 else 566 args = p; 567 } 568 569 if (strcmp (cmd, "trace") == 0) 570 { 571 if (strcmp (args, "on") == 0) 572 trace = 1; 573 else if (strcmp (args, "off") == 0) 574 trace = 0; 575 else 576 printf ("The 'sim trace' command expects 'on' or 'off' " 577 "as an argument.\n"); 578 } 579 else if (strcmp (cmd, "verbose") == 0) 580 { 581 if (strcmp (args, "on") == 0) 582 verbose = 1; 583 else if (strcmp (args, "noisy") == 0) 584 verbose = 2; 585 else if (strcmp (args, "off") == 0) 586 verbose = 0; 587 else 588 printf ("The 'sim verbose' command expects 'on', 'noisy', or 'off'" 589 " as an argument.\n"); 590 } 591 else 592 printf ("The 'sim' command expects either 'trace' or 'verbose'" 593 " as a subcommand.\n"); 594 595 free (p); 596 } 597 598 /* Stub for command completion. */ 599 600 char ** 601 sim_complete_command (SIM_DESC sd, const char *text, const char *word) 602 { 603 return NULL; 604 } 605