| 1 | /* Main simulator entry points specific to the CRIS. |
| 2 | Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc. |
| 3 | Contributed by Axis Communications. |
| 4 | |
| 5 | This file is part of the GNU simulators. |
| 6 | |
| 7 | This program is free software; you can redistribute it and/or modify |
| 8 | it under the terms of the GNU General Public License as published by |
| 9 | the Free Software Foundation; either version 2, or (at your option) |
| 10 | any later version. |
| 11 | |
| 12 | This program is distributed in the hope that it will be useful, |
| 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | GNU General Public License for more details. |
| 16 | |
| 17 | You should have received a copy of the GNU General Public License along |
| 18 | with this program; if not, write to the Free Software Foundation, Inc., |
| 19 | 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| 20 | |
| 21 | /* Based on the fr30 file, mixing in bits from the i960 and pruning of |
| 22 | dead code. */ |
| 23 | |
| 24 | #include "libiberty.h" |
| 25 | #include "bfd.h" |
| 26 | |
| 27 | #include "sim-main.h" |
| 28 | #ifdef HAVE_STDLIB_H |
| 29 | #include <stdlib.h> |
| 30 | #endif |
| 31 | #include "sim-options.h" |
| 32 | #include "dis-asm.h" |
| 33 | |
| 34 | /* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used |
| 35 | in other dirs; also lacking there). Patch around it for major systems. */ |
| 36 | #if defined (HAVE_ENVIRON) || defined (__GLIBC__) |
| 37 | extern char **environ; |
| 38 | #define GET_ENVIRON() environ |
| 39 | #else |
| 40 | char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL }; |
| 41 | #define GET_ENVIRON() missing_environ |
| 42 | #endif |
| 43 | |
| 44 | /* AUX vector entries. */ |
| 45 | #define TARGET_AT_NULL 0 |
| 46 | #define TARGET_AT_PHDR 3 |
| 47 | #define TARGET_AT_PHENT 4 |
| 48 | #define TARGET_AT_PHNUM 5 |
| 49 | #define TARGET_AT_PAGESZ 6 |
| 50 | #define TARGET_AT_BASE 7 |
| 51 | #define TARGET_AT_FLAGS 8 |
| 52 | #define TARGET_AT_ENTRY 9 |
| 53 | #define TARGET_AT_UID 11 |
| 54 | #define TARGET_AT_EUID 12 |
| 55 | #define TARGET_AT_GID 13 |
| 56 | #define TARGET_AT_EGID 14 |
| 57 | #define TARGET_AT_HWCAP 16 |
| 58 | #define TARGET_AT_CLKTCK 17 |
| 59 | |
| 60 | /* Used with get_progbounds to find out how much memory is needed for the |
| 61 | program. We don't want to allocate more, since that could mask |
| 62 | invalid memory accesses program bugs. */ |
| 63 | struct progbounds { |
| 64 | USI startmem; |
| 65 | USI endmem; |
| 66 | }; |
| 67 | |
| 68 | static void free_state (SIM_DESC); |
| 69 | static void get_progbounds (bfd *, asection *, void *); |
| 70 | static SIM_RC cris_option_handler (SIM_DESC, sim_cpu *, int, char *, int); |
| 71 | |
| 72 | /* Since we don't build the cgen-opcode table, we use the old |
| 73 | disassembler. */ |
| 74 | static CGEN_DISASSEMBLER cris_disassemble_insn; |
| 75 | |
| 76 | /* By default, we set up stack and environment variables like the Linux |
| 77 | kernel. */ |
| 78 | static char cris_bare_iron = 0; |
| 79 | |
| 80 | /* Whether 0x9000000xx have simulator-specific meanings. */ |
| 81 | char cris_have_900000xxif = 0; |
| 82 | |
| 83 | /* What to do when we face a more or less unknown syscall. */ |
| 84 | enum cris_unknown_syscall_action_type cris_unknown_syscall_action |
| 85 | = CRIS_USYSC_MSG_STOP; |
| 86 | |
| 87 | /* Records simulator descriptor so utilities like cris_dump_regs can be |
| 88 | called from gdb. */ |
| 89 | SIM_DESC current_state; |
| 90 | |
| 91 | /* CRIS-specific options. */ |
| 92 | typedef enum { |
| 93 | OPTION_CRIS_STATS = OPTION_START, |
| 94 | OPTION_CRIS_TRACE, |
| 95 | OPTION_CRIS_NAKED, |
| 96 | OPTION_CRIS_900000XXIF, |
| 97 | OPTION_CRIS_UNKNOWN_SYSCALL |
| 98 | } CRIS_OPTIONS; |
| 99 | |
| 100 | static const OPTION cris_options[] = |
| 101 | { |
| 102 | { {"cris-cycles", required_argument, NULL, OPTION_CRIS_STATS}, |
| 103 | '\0', "basic|unaligned|schedulable|all", |
| 104 | "Dump execution statistics", |
| 105 | cris_option_handler, NULL }, |
| 106 | { {"cris-trace", required_argument, NULL, OPTION_CRIS_TRACE}, |
| 107 | '\0', "basic", |
| 108 | "Emit trace information while running", |
| 109 | cris_option_handler, NULL }, |
| 110 | { {"cris-naked", no_argument, NULL, OPTION_CRIS_NAKED}, |
| 111 | '\0', NULL, "Don't set up stack and environment", |
| 112 | cris_option_handler, NULL }, |
| 113 | { {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF}, |
| 114 | '\0', NULL, "Define addresses at 0x900000xx with simulator semantics", |
| 115 | cris_option_handler, NULL }, |
| 116 | { {"cris-unknown-syscall", required_argument, NULL, |
| 117 | OPTION_CRIS_UNKNOWN_SYSCALL}, |
| 118 | '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call", |
| 119 | cris_option_handler, NULL }, |
| 120 | { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL } |
| 121 | }; |
| 122 | \f |
| 123 | /* Add the CRIS-specific option list to the simulator. */ |
| 124 | |
| 125 | SIM_RC |
| 126 | cris_option_install (SIM_DESC sd) |
| 127 | { |
| 128 | SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); |
| 129 | if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK) |
| 130 | return SIM_RC_FAIL; |
| 131 | return SIM_RC_OK; |
| 132 | } |
| 133 | |
| 134 | /* Handle CRIS-specific options. */ |
| 135 | |
| 136 | static SIM_RC |
| 137 | cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt, |
| 138 | char *arg, int is_command ATTRIBUTE_UNUSED) |
| 139 | { |
| 140 | /* The options are CRIS-specific, but cpu-specific option-handling is |
| 141 | broken; required to being with "--cpu0-". We store the flags in an |
| 142 | unused field in the global state structure and move the flags over |
| 143 | to the module-specific CPU data when we store things in the |
| 144 | cpu-specific structure. */ |
| 145 | char *tracefp = STATE_TRACE_FLAGS (sd); |
| 146 | |
| 147 | switch ((CRIS_OPTIONS) opt) |
| 148 | { |
| 149 | case OPTION_CRIS_STATS: |
| 150 | if (strcmp (arg, "basic") == 0) |
| 151 | *tracefp = FLAG_CRIS_MISC_PROFILE_SIMPLE; |
| 152 | else if (strcmp (arg, "unaligned") == 0) |
| 153 | *tracefp |
| 154 | = (FLAG_CRIS_MISC_PROFILE_UNALIGNED |
| 155 | | FLAG_CRIS_MISC_PROFILE_SIMPLE); |
| 156 | else if (strcmp (arg, "schedulable") == 0) |
| 157 | *tracefp |
| 158 | = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE |
| 159 | | FLAG_CRIS_MISC_PROFILE_SIMPLE); |
| 160 | else if (strcmp (arg, "all") == 0) |
| 161 | *tracefp = FLAG_CRIS_MISC_PROFILE_ALL; |
| 162 | else |
| 163 | { |
| 164 | /* Beware; the framework does not handle the error case; |
| 165 | we have to do it ourselves. */ |
| 166 | sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg); |
| 167 | return SIM_RC_FAIL; |
| 168 | } |
| 169 | break; |
| 170 | |
| 171 | case OPTION_CRIS_TRACE: |
| 172 | if (strcmp (arg, "basic") == 0) |
| 173 | *tracefp |= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE; |
| 174 | else |
| 175 | { |
| 176 | sim_io_eprintf (sd, "Unknown option `--cris-trace=%s'\n", arg); |
| 177 | return SIM_RC_FAIL; |
| 178 | } |
| 179 | break; |
| 180 | |
| 181 | case OPTION_CRIS_NAKED: |
| 182 | cris_bare_iron = 1; |
| 183 | break; |
| 184 | |
| 185 | case OPTION_CRIS_900000XXIF: |
| 186 | cris_have_900000xxif = 1; |
| 187 | break; |
| 188 | |
| 189 | case OPTION_CRIS_UNKNOWN_SYSCALL: |
| 190 | if (strcmp (arg, "enosys") == 0) |
| 191 | cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS; |
| 192 | else if (strcmp (arg, "enosys-quiet") == 0) |
| 193 | cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS; |
| 194 | else if (strcmp (arg, "stop") == 0) |
| 195 | cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP; |
| 196 | else |
| 197 | { |
| 198 | sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n", |
| 199 | arg); |
| 200 | return SIM_RC_FAIL; |
| 201 | } |
| 202 | break; |
| 203 | |
| 204 | default: |
| 205 | /* We'll actually never get here; the caller handles the error |
| 206 | case. */ |
| 207 | sim_io_eprintf (sd, "Unknown option `%s'\n", arg); |
| 208 | return SIM_RC_FAIL; |
| 209 | } |
| 210 | |
| 211 | /* Imply --profile-model=on. */ |
| 212 | return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on"); |
| 213 | } |
| 214 | |
| 215 | /* Cover function of sim_state_free to free the cpu buffers as well. */ |
| 216 | |
| 217 | static void |
| 218 | free_state (SIM_DESC sd) |
| 219 | { |
| 220 | if (STATE_MODULES (sd) != NULL) |
| 221 | sim_module_uninstall (sd); |
| 222 | sim_cpu_free_all (sd); |
| 223 | sim_state_free (sd); |
| 224 | } |
| 225 | |
| 226 | /* BFD section iterator to find the highest allocated section address |
| 227 | (plus one). If we could, we should use the program header table |
| 228 | instead, but we can't get to that using bfd. */ |
| 229 | |
| 230 | void |
| 231 | get_progbounds (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp) |
| 232 | { |
| 233 | struct progbounds *pbp = (struct progbounds *) vp; |
| 234 | |
| 235 | if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC)) |
| 236 | { |
| 237 | bfd_size_type sec_size = bfd_get_section_size (s); |
| 238 | bfd_size_type sec_start = bfd_get_section_vma (abfd, s); |
| 239 | bfd_size_type sec_end = sec_start + sec_size; |
| 240 | |
| 241 | if (sec_end > pbp->endmem) |
| 242 | pbp->endmem = sec_end; |
| 243 | |
| 244 | if (sec_start < pbp->startmem) |
| 245 | pbp->startmem = sec_start; |
| 246 | } |
| 247 | } |
| 248 | |
| 249 | /* Create an instance of the simulator. */ |
| 250 | |
| 251 | SIM_DESC |
| 252 | sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd, |
| 253 | char **argv) |
| 254 | { |
| 255 | char c; |
| 256 | int i; |
| 257 | USI startmem = 0; |
| 258 | USI endmem = CRIS_DEFAULT_MEM_SIZE; |
| 259 | USI endbrk = endmem; |
| 260 | USI stack_low = 0; |
| 261 | SIM_DESC sd = sim_state_alloc (kind, callback); |
| 262 | |
| 263 | /* Can't initialize to "" below. It's either a GCC bug in old |
| 264 | releases (up to and including 2.95.3 (.4 in debian) or a bug in the |
| 265 | standard ;-) that the rest of the elements won't be initialized. */ |
| 266 | bfd_byte sp_init[4] = {0, 0, 0, 0}; |
| 267 | |
| 268 | /* The cpu data is kept in a separately allocated chunk of memory. */ |
| 269 | if (sim_cpu_alloc_all (sd, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK) |
| 270 | { |
| 271 | free_state (sd); |
| 272 | return 0; |
| 273 | } |
| 274 | |
| 275 | if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK) |
| 276 | { |
| 277 | free_state (sd); |
| 278 | return 0; |
| 279 | } |
| 280 | |
| 281 | /* getopt will print the error message so we just have to exit if this fails. |
| 282 | FIXME: Hmmm... in the case of gdb we need getopt to call |
| 283 | print_filtered. */ |
| 284 | if (sim_parse_args (sd, argv) != SIM_RC_OK) |
| 285 | { |
| 286 | free_state (sd); |
| 287 | return 0; |
| 288 | } |
| 289 | |
| 290 | /* If we have a binary program, endianness-setting would not be taken |
| 291 | from elsewhere unfortunately, so set it here. At the time of this |
| 292 | writing, it isn't used until sim_config, but that might change so |
| 293 | set it here before memory is defined or touched. */ |
| 294 | current_target_byte_order = LITTLE_ENDIAN; |
| 295 | |
| 296 | /* check for/establish the reference program image */ |
| 297 | if (sim_analyze_program (sd, |
| 298 | (STATE_PROG_ARGV (sd) != NULL |
| 299 | ? *STATE_PROG_ARGV (sd) |
| 300 | : NULL), |
| 301 | abfd) != SIM_RC_OK) |
| 302 | { |
| 303 | free_state (sd); |
| 304 | return 0; |
| 305 | } |
| 306 | |
| 307 | /* For CRIS simulator-specific use, we need to find out the bounds of |
| 308 | the program as well, which is not done by sim_analyze_program |
| 309 | above. */ |
| 310 | if (STATE_PROG_BFD (sd)) |
| 311 | { |
| 312 | struct progbounds pb; |
| 313 | |
| 314 | /* The sections should now be accessible using bfd functions. */ |
| 315 | pb.startmem = 0x7fffffff; |
| 316 | pb.endmem = 0; |
| 317 | bfd_map_over_sections (STATE_PROG_BFD (sd), get_progbounds, &pb); |
| 318 | |
| 319 | /* We align the area that the program uses to page boundaries. */ |
| 320 | startmem = pb.startmem & ~8191; |
| 321 | endbrk = pb.endmem; |
| 322 | endmem = (endbrk + 8191) & ~8191; |
| 323 | } |
| 324 | |
| 325 | /* Find out how much room is needed for the environment and argv, create |
| 326 | that memory and fill it. Only do this when there's a program |
| 327 | specified. */ |
| 328 | if (STATE_PROG_BFD (sd) && !cris_bare_iron) |
| 329 | { |
| 330 | char *name = bfd_get_filename (STATE_PROG_BFD (sd)); |
| 331 | char **my_environ = GET_ENVIRON (); |
| 332 | /* We use these maps to give the same behavior as the old xsim |
| 333 | simulator. */ |
| 334 | USI envtop = 0x40000000; |
| 335 | USI stacktop = 0x3e000000; |
| 336 | USI envstart; |
| 337 | int envc; |
| 338 | int len = strlen (name) + 1; |
| 339 | USI epp, epp0; |
| 340 | USI stacklen; |
| 341 | int i; |
| 342 | char **prog_argv = STATE_PROG_ARGV (sd); |
| 343 | int my_argc = 0; |
| 344 | /* All CPU:s have the same memory map, apparently. */ |
| 345 | SIM_CPU *cpu = STATE_CPU (sd, 0); |
| 346 | USI csp; |
| 347 | bfd_byte buf[4]; |
| 348 | |
| 349 | /* Count in the environment as well. */ |
| 350 | for (envc = 0; my_environ[envc] != NULL; envc++) |
| 351 | len += strlen (my_environ[envc]) + 1; |
| 352 | |
| 353 | for (i = 0; prog_argv[i] != NULL; my_argc++, i++) |
| 354 | len += strlen (prog_argv[i]) + 1; |
| 355 | |
| 356 | envstart = (envtop - len) & ~8191; |
| 357 | |
| 358 | /* Create read-only block for the environment strings. */ |
| 359 | sim_core_attach (sd, NULL, 0, access_read, 0, |
| 360 | envstart, (len + 8191) & ~8191, |
| 361 | 0, NULL, NULL); |
| 362 | |
| 363 | /* This shouldn't happen. */ |
| 364 | if (envstart < stacktop) |
| 365 | stacktop = envstart - 64 * 8192; |
| 366 | |
| 367 | csp = stacktop; |
| 368 | |
| 369 | /* Note that the linux kernel does not correctly compute the storage |
| 370 | needs for the static-exe AUX vector. */ |
| 371 | csp -= 4 * 4 * 2; |
| 372 | |
| 373 | csp -= (envc + 1) * 4; |
| 374 | csp -= (my_argc + 1) * 4; |
| 375 | csp -= 4; |
| 376 | |
| 377 | /* Write the target representation of the start-up-value for the |
| 378 | stack-pointer suitable for register initialization below. */ |
| 379 | bfd_putl32 (csp, sp_init); |
| 380 | |
| 381 | /* If we make this 1M higher; say 8192*1024, we have to take |
| 382 | special precautions for pthreads, because pthreads assumes that |
| 383 | the memory that low isn't mmapped, and that it can mmap it |
| 384 | without fallback in case of failure (and we fail ungracefully |
| 385 | long before *that*: the memory isn't accounted for in our mmap |
| 386 | list). */ |
| 387 | stack_low = (csp - (7168*1024)) & ~8191; |
| 388 | |
| 389 | stacklen = stacktop - stack_low; |
| 390 | |
| 391 | /* Tee hee, we have an executable stack. Well, it's necessary to |
| 392 | test GCC trampolines... */ |
| 393 | sim_core_attach (sd, NULL, 0, access_read_write_exec, 0, |
| 394 | stack_low, stacklen, |
| 395 | 0, NULL, NULL); |
| 396 | |
| 397 | epp = epp0 = envstart; |
| 398 | |
| 399 | /* Can't use sim_core_write_unaligned_4 without everything |
| 400 | initialized when tracing, and then these writes would get into |
| 401 | the trace. */ |
| 402 | #define write_dword(addr, data) \ |
| 403 | do \ |
| 404 | { \ |
| 405 | USI data_ = data; \ |
| 406 | USI addr_ = addr; \ |
| 407 | bfd_putl32 (data_, buf); \ |
| 408 | if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4) \ |
| 409 | goto abandon_chip; \ |
| 410 | } \ |
| 411 | while (0) |
| 412 | |
| 413 | write_dword (csp, my_argc); |
| 414 | csp += 4; |
| 415 | |
| 416 | for (i = 0; i < my_argc; i++, csp += 4) |
| 417 | { |
| 418 | size_t strln = strlen (prog_argv[i]) + 1; |
| 419 | |
| 420 | if (sim_core_write_buffer (sd, cpu, 0, prog_argv[i], epp, strln) |
| 421 | != strln) |
| 422 | goto abandon_chip; |
| 423 | |
| 424 | write_dword (csp, envstart + epp - epp0); |
| 425 | epp += strln; |
| 426 | } |
| 427 | |
| 428 | write_dword (csp, 0); |
| 429 | csp += 4; |
| 430 | |
| 431 | for (i = 0; i < envc; i++, csp += 4) |
| 432 | { |
| 433 | unsigned int strln = strlen (my_environ[i]) + 1; |
| 434 | |
| 435 | if (sim_core_write_buffer (sd, cpu, 0, my_environ[i], epp, strln) |
| 436 | != strln) |
| 437 | goto abandon_chip; |
| 438 | |
| 439 | write_dword (csp, envstart + epp - epp0); |
| 440 | epp += strln; |
| 441 | } |
| 442 | |
| 443 | write_dword (csp, 0); |
| 444 | csp += 4; |
| 445 | |
| 446 | #define NEW_AUX_ENT(nr, id, val) \ |
| 447 | do \ |
| 448 | { \ |
| 449 | write_dword (csp + (nr) * 4 * 2, (id)); \ |
| 450 | write_dword (csp + (nr) * 4 * 2 + 4, (val)); \ |
| 451 | } \ |
| 452 | while (0) |
| 453 | |
| 454 | /* Note that there are some extra AUX entries for a dynlinked |
| 455 | program loaded image. */ |
| 456 | |
| 457 | /* AUX entries always present. */ |
| 458 | NEW_AUX_ENT (0, TARGET_AT_HWCAP, 0); |
| 459 | NEW_AUX_ENT (1, TARGET_AT_PAGESZ, 8192); |
| 460 | NEW_AUX_ENT (2, TARGET_AT_CLKTCK, 100); |
| 461 | |
| 462 | csp += 4 * 2 * 3; |
| 463 | NEW_AUX_ENT (0, TARGET_AT_NULL, 0); |
| 464 | #undef NEW_AUX_ENT |
| 465 | |
| 466 | /* Register R10 should hold 0 at static start (no initfunc), but |
| 467 | that's the default, so don't bother. */ |
| 468 | } |
| 469 | |
| 470 | /* Allocate core managed memory if none specified by user. */ |
| 471 | if (sim_core_read_buffer (sd, NULL, read_map, &c, startmem, 1) == 0) |
| 472 | sim_do_commandf (sd, "memory region 0x%lx,0x%lx", startmem, |
| 473 | endmem - startmem); |
| 474 | |
| 475 | /* Allocate simulator I/O managed memory if none specified by user. */ |
| 476 | if (cris_have_900000xxif) |
| 477 | { |
| 478 | if (sim_core_read_buffer (sd, NULL, read_map, &c, 0x90000000, 1) == 0) |
| 479 | sim_core_attach (sd, NULL, 0, access_write, 0, 0x90000000, 0x100, |
| 480 | 0, &cris_devices, NULL); |
| 481 | else |
| 482 | { |
| 483 | (*callback-> |
| 484 | printf_filtered) (callback, |
| 485 | "Seeing --cris-900000xx with memory defined there\n"); |
| 486 | goto abandon_chip; |
| 487 | } |
| 488 | } |
| 489 | |
| 490 | /* Establish any remaining configuration options. */ |
| 491 | if (sim_config (sd) != SIM_RC_OK) |
| 492 | { |
| 493 | abandon_chip: |
| 494 | free_state (sd); |
| 495 | return 0; |
| 496 | } |
| 497 | |
| 498 | if (sim_post_argv_init (sd) != SIM_RC_OK) |
| 499 | { |
| 500 | free_state (sd); |
| 501 | return 0; |
| 502 | } |
| 503 | |
| 504 | /* Open a copy of the cpu descriptor table. */ |
| 505 | { |
| 506 | CGEN_CPU_DESC cd = cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name, |
| 507 | CGEN_ENDIAN_LITTLE); |
| 508 | for (i = 0; i < MAX_NR_PROCESSORS; ++i) |
| 509 | { |
| 510 | SIM_CPU *cpu = STATE_CPU (sd, i); |
| 511 | CPU_CPU_DESC (cpu) = cd; |
| 512 | CPU_DISASSEMBLER (cpu) = cris_disassemble_insn; |
| 513 | |
| 514 | /* See cris_option_handler for the reason why this is needed. */ |
| 515 | CPU_CRIS_MISC_PROFILE (cpu)->flags = STATE_TRACE_FLAGS (sd)[0]; |
| 516 | |
| 517 | /* Set SP to the stack we allocated above. */ |
| 518 | (* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (char *) sp_init, 4); |
| 519 | |
| 520 | /* Set the simulator environment data. */ |
| 521 | cpu->highest_mmapped_page = NULL; |
| 522 | cpu->endmem = endmem; |
| 523 | cpu->endbrk = endbrk; |
| 524 | cpu->stack_low = stack_low; |
| 525 | cpu->syscalls = 0; |
| 526 | cpu->m1threads = 0; |
| 527 | cpu->threadno = 0; |
| 528 | cpu->max_threadid = 0; |
| 529 | cpu->thread_data = NULL; |
| 530 | memset (cpu->sighandler, 0, sizeof (cpu->sighandler)); |
| 531 | cpu->make_thread_cpu_data = NULL; |
| 532 | cpu->thread_cpu_data_size = 0; |
| 533 | #if WITH_HW |
| 534 | cpu->deliver_interrupt = NULL; |
| 535 | #endif |
| 536 | } |
| 537 | #if WITH_HW |
| 538 | /* Always be cycle-accurate and call before/after functions if |
| 539 | with-hardware. */ |
| 540 | sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on"); |
| 541 | #endif |
| 542 | } |
| 543 | |
| 544 | /* Initialize various cgen things not done by common framework. |
| 545 | Must be done after cris_cgen_cpu_open. */ |
| 546 | cgen_init (sd); |
| 547 | |
| 548 | /* Store in a global so things like cris_dump_regs can be invoked |
| 549 | from the gdb command line. */ |
| 550 | current_state = sd; |
| 551 | |
| 552 | cris_set_callbacks (callback); |
| 553 | |
| 554 | return sd; |
| 555 | } |
| 556 | |
| 557 | void |
| 558 | sim_close (SIM_DESC sd, int quitting ATTRIBUTE_UNUSED) |
| 559 | { |
| 560 | cris_cgen_cpu_close (CPU_CPU_DESC (STATE_CPU (sd, 0))); |
| 561 | sim_module_uninstall (sd); |
| 562 | } |
| 563 | \f |
| 564 | SIM_RC |
| 565 | sim_create_inferior (SIM_DESC sd, struct bfd *abfd, |
| 566 | char **argv ATTRIBUTE_UNUSED, |
| 567 | char **envp ATTRIBUTE_UNUSED) |
| 568 | { |
| 569 | SIM_CPU *current_cpu = STATE_CPU (sd, 0); |
| 570 | SIM_ADDR addr; |
| 571 | |
| 572 | if (abfd != NULL) |
| 573 | addr = bfd_get_start_address (abfd); |
| 574 | else |
| 575 | addr = 0; |
| 576 | sim_pc_set (current_cpu, addr); |
| 577 | |
| 578 | /* Other simulators have #if 0:d code that says |
| 579 | STATE_ARGV (sd) = sim_copy_argv (argv); |
| 580 | STATE_ENVP (sd) = sim_copy_argv (envp); |
| 581 | Enabling that gives you not-found link-errors for sim_copy_argv. |
| 582 | FIXME: Do archaeology to find out more. */ |
| 583 | |
| 584 | return SIM_RC_OK; |
| 585 | } |
| 586 | |
| 587 | void |
| 588 | sim_do_command (SIM_DESC sd, char *cmd) |
| 589 | { |
| 590 | if (sim_args_command (sd, cmd) != SIM_RC_OK) |
| 591 | sim_io_eprintf (sd, "Unknown command `%s'\n", cmd); |
| 592 | } |
| 593 | \f |
| 594 | /* Disassemble an instruction. */ |
| 595 | |
| 596 | static void |
| 597 | cris_disassemble_insn (SIM_CPU *cpu, |
| 598 | const CGEN_INSN *insn ATTRIBUTE_UNUSED, |
| 599 | const ARGBUF *abuf ATTRIBUTE_UNUSED, |
| 600 | IADDR pc, char *buf) |
| 601 | { |
| 602 | disassembler_ftype pinsn; |
| 603 | struct disassemble_info disasm_info; |
| 604 | SFILE sfile; |
| 605 | SIM_DESC sd = CPU_STATE (cpu); |
| 606 | |
| 607 | sfile.buffer = sfile.current = buf; |
| 608 | INIT_DISASSEMBLE_INFO (disasm_info, (FILE *) &sfile, |
| 609 | (fprintf_ftype) sim_disasm_sprintf); |
| 610 | disasm_info.endian = |
| 611 | (bfd_big_endian (STATE_PROG_BFD (sd)) ? BFD_ENDIAN_BIG |
| 612 | : bfd_little_endian (STATE_PROG_BFD (sd)) ? BFD_ENDIAN_LITTLE |
| 613 | : BFD_ENDIAN_UNKNOWN); |
| 614 | /* We live with the cast until the prototype is fixed, or else we get a |
| 615 | warning because the functions differ in the signedness of one parameter. */ |
| 616 | disasm_info.read_memory_func = |
| 617 | sim_disasm_read_memory; |
| 618 | disasm_info.memory_error_func = sim_disasm_perror_memory; |
| 619 | disasm_info.application_data = (PTR) cpu; |
| 620 | pinsn = cris_get_disassembler (STATE_PROG_BFD (sd)); |
| 621 | (*pinsn) (pc, &disasm_info); |
| 622 | } |