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