sim/cris/sim-if.c

   1 /* Main simulator entry points specific to the CRIS.
   2    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Axis Communications.
   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 /* 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 #include "elf-bfd.h"
  27
  28 #include "sim-main.h"
  29 #ifdef HAVE_STDLIB_H
  30 #include <stdlib.h>
  31 #endif
  32 #include <errno.h>
  33 #include "sim-options.h"
  34 #include "dis-asm.h"
  35
  36 /* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used
  37    in other dirs; also lacking there).  Patch around it for major systems.  */
  38 #if defined (HAVE_ENVIRON) || defined (__GLIBC__)
  39 extern char **environ;
  40 #define GET_ENVIRON() environ
  41 #else
  42 char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL };
  43 #define GET_ENVIRON() missing_environ
  44 #endif
  45
  46 /* Used with get_progbounds to find out how much memory is needed for the
  47    program.  We don't want to allocate more, since that could mask
  48    invalid memory accesses program bugs.  */
  49 struct progbounds {
  50   USI startmem;
  51   USI endmem;
  52   USI end_loadmem;
  53   USI start_nonloadmem;
  54 };
  55
  56 static void free_state (SIM_DESC);
  57 static void get_progbounds_iterator (bfd *, asection *, void *);
  58 static SIM_RC cris_option_handler (SIM_DESC, sim_cpu *, int, char *, int);
  59
  60 /* Since we don't build the cgen-opcode table, we use the old
  61    disassembler.  */
  62 static CGEN_DISASSEMBLER cris_disassemble_insn;
  63
  64 /* By default, we set up stack and environment variables like the Linux
  65    kernel.  */
  66 static char cris_bare_iron = 0;
  67
  68 /* Whether 0x9000000xx have simulator-specific meanings.  */
  69 char cris_have_900000xxif = 0;
  70
  71 /* Used to optionally override the default start address of the
  72    simulation.  */
  73 static USI cris_start_address = 0xffffffffu;
  74
  75 /* Used to optionally add offsets to the loaded image and its start
  76    address.  (Not used for the interpreter of dynamically loaded
  77    programs or the DSO:s.)  */
  78 static int cris_program_offset = 0;
  79
  80 /* What to do when we face a more or less unknown syscall.  */
  81 enum cris_unknown_syscall_action_type cris_unknown_syscall_action
  82   = CRIS_USYSC_MSG_STOP;
  83
  84 /* Records simulator descriptor so utilities like cris_dump_regs can be
  85    called from gdb.  */
  86 SIM_DESC current_state;
  87
  88 /* CRIS-specific options.  */
  89 typedef enum {
  90   OPTION_CRIS_STATS = OPTION_START,
  91   OPTION_CRIS_TRACE,
  92   OPTION_CRIS_NAKED,
  93   OPTION_CRIS_PROGRAM_OFFSET,
  94   OPTION_CRIS_STARTADDR,
  95   OPTION_CRIS_900000XXIF,
  96   OPTION_CRIS_UNKNOWN_SYSCALL
  97 } CRIS_OPTIONS;
  98
  99 static const OPTION cris_options[] =
 100 {
 101   { {"cris-cycles", required_argument, NULL, OPTION_CRIS_STATS},
 102       '\0', "basic|unaligned|schedulable|all",
 103     "Dump execution statistics",
 104       cris_option_handler, NULL },
 105   { {"cris-trace", required_argument, NULL, OPTION_CRIS_TRACE},
 106       '\0', "basic",
 107     "Emit trace information while running",
 108       cris_option_handler, NULL },
 109   { {"cris-naked", no_argument, NULL, OPTION_CRIS_NAKED},
 110      '\0', NULL, "Don't set up stack and environment",
 111      cris_option_handler, NULL },
 112   { {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF},
 113      '\0', NULL, "Define addresses at 0x900000xx with simulator semantics",
 114      cris_option_handler, NULL },
 115   { {"cris-unknown-syscall", required_argument, NULL,
 116      OPTION_CRIS_UNKNOWN_SYSCALL},
 117      '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
 118      cris_option_handler, NULL },
 119   { {"cris-program-offset", required_argument, NULL,
 120      OPTION_CRIS_PROGRAM_OFFSET},
 121       '\0', "OFFSET",
 122     "Offset image addresses and default start address of a program",
 123       cris_option_handler },
 124   { {"cris-start-address", required_argument, NULL, OPTION_CRIS_STARTADDR},
 125       '\0', "ADDRESS", "Set start address",
 126       cris_option_handler },
 127   { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
 128 };
 129 \f
 130 /* Add the CRIS-specific option list to the simulator.  */
 131
 132 SIM_RC
 133 cris_option_install (SIM_DESC sd)
 134 {
 135   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 136   if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK)
 137     return SIM_RC_FAIL;
 138   return SIM_RC_OK;
 139 }
 140
 141 /* Handle CRIS-specific options.  */
 142
 143 static SIM_RC
 144 cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
 145                      char *arg, int is_command ATTRIBUTE_UNUSED)
 146 {
 147   /* The options are CRIS-specific, but cpu-specific option-handling is
 148      broken; required to being with "--cpu0-".  We store the flags in an
 149      unused field in the global state structure and move the flags over
 150      to the module-specific CPU data when we store things in the
 151      cpu-specific structure.  */
 152   char *tracefp = STATE_TRACE_FLAGS (sd);
 153   char *chp = arg;
 154
 155   switch ((CRIS_OPTIONS) opt)
 156     {
 157       case OPTION_CRIS_STATS:
 158         if (strcmp (arg, "basic") == 0)
 159           *tracefp = FLAG_CRIS_MISC_PROFILE_SIMPLE;
 160         else if (strcmp (arg, "unaligned") == 0)
 161           *tracefp
 162             = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
 163                | FLAG_CRIS_MISC_PROFILE_SIMPLE);
 164         else if (strcmp (arg, "schedulable") == 0)
 165           *tracefp
 166             = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
 167                | FLAG_CRIS_MISC_PROFILE_SIMPLE);
 168         else if (strcmp (arg, "all") == 0)
 169           *tracefp = FLAG_CRIS_MISC_PROFILE_ALL;
 170         else
 171           {
 172             /* Beware; the framework does not handle the error case;
 173                we have to do it ourselves.  */
 174             sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg);
 175             return SIM_RC_FAIL;
 176           }
 177         break;
 178
 179       case OPTION_CRIS_TRACE:
 180         if (strcmp (arg, "basic") == 0)
 181           *tracefp |= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE;
 182         else
 183           {
 184             sim_io_eprintf (sd, "Unknown option `--cris-trace=%s'\n", arg);
 185             return SIM_RC_FAIL;
 186           }
 187         break;
 188
 189       case OPTION_CRIS_NAKED:
 190         cris_bare_iron = 1;
 191         break;
 192
 193       case OPTION_CRIS_900000XXIF:
 194         cris_have_900000xxif = 1;
 195         break;
 196
 197       case OPTION_CRIS_STARTADDR:
 198         errno = 0;
 199         cris_start_address = (USI) strtoul (chp, &chp, 0);
 200
 201         if (errno != 0 || *chp != 0)
 202           {
 203             sim_io_eprintf (sd, "Invalid option `--cris-start-address=%s'\n",
 204                             arg);
 205             return SIM_RC_FAIL;
 206           }
 207         break;
 208
 209       case OPTION_CRIS_PROGRAM_OFFSET:
 210         errno = 0;
 211         cris_program_offset = (int) strtol (chp, &chp, 0);
 212
 213         if (errno != 0 || *chp != 0)
 214           {
 215             sim_io_eprintf (sd, "Invalid option `--cris-program-offset=%s'\n",
 216                             arg);
 217             return SIM_RC_FAIL;
 218           }
 219         break;
 220
 221       case OPTION_CRIS_UNKNOWN_SYSCALL:
 222         if (strcmp (arg, "enosys") == 0)
 223           cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS;
 224         else if (strcmp (arg, "enosys-quiet") == 0)
 225           cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS;
 226         else if (strcmp (arg, "stop") == 0)
 227           cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP;
 228         else
 229           {
 230             sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n",
 231                             arg);
 232             return SIM_RC_FAIL;
 233           }
 234         break;
 235
 236       default:
 237         /* We'll actually never get here; the caller handles the error
 238            case.  */
 239         sim_io_eprintf (sd, "Unknown option `%s'\n", arg);
 240         return SIM_RC_FAIL;
 241     }
 242
 243   /* Imply --profile-model=on.  */
 244   return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
 245 }
 246
 247 /* FIXME: Remove these, globalize those in sim-load.c, move elsewhere.  */
 248
 249 static void
 250 xprintf  (host_callback *callback, const char *fmt, ...)
 251 {
 252   va_list ap;
 253
 254   va_start (ap, fmt);
 255
 256   (*callback->vprintf_filtered) (callback, fmt, ap);
 257
 258   va_end (ap);
 259 }
 260
 261 static void
 262 eprintf (host_callback *callback, const char *fmt, ...)
 263 {
 264   va_list ap;
 265
 266   va_start (ap, fmt);
 267
 268   (*callback->evprintf_filtered) (callback, fmt, ap);
 269
 270   va_end (ap);
 271 }
 272
 273 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
 274    using the program headers, not sections, in order to make sure that
 275    the program headers themeselves are also loaded.  The caller is
 276    responsible for asserting that ABFD is an ELF file.  */
 277
 278 static bfd_boolean
 279 cris_load_elf_file (SIM_DESC sd, struct bfd *abfd, sim_write_fn do_write)
 280 {
 281   Elf_Internal_Phdr *phdr;
 282   int n_hdrs;
 283   int i;
 284   bfd_boolean verbose = STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG;
 285   host_callback *callback = STATE_CALLBACK (sd);
 286
 287   phdr = elf_tdata (abfd)->phdr;
 288   n_hdrs = elf_elfheader (abfd)->e_phnum;
 289
 290   /* We're only interested in PT_LOAD; all necessary information
 291      should be covered by that.  */
 292   for (i = 0; i < n_hdrs; i++)
 293     {
 294       bfd_byte *buf;
 295       bfd_vma lma = STATE_LOAD_AT_LMA_P (sd)
 296         ? phdr[i].p_paddr : phdr[i].p_vaddr;
 297
 298       if (phdr[i].p_type != PT_LOAD)
 299         continue;
 300
 301       buf = xmalloc (phdr[i].p_filesz);
 302
 303       if (verbose)
 304         xprintf (callback, "Loading segment at 0x%lx, size 0x%lx\n",
 305                  lma, phdr[i].p_filesz);
 306
 307       if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
 308           || (bfd_bread (buf, phdr[i].p_filesz, abfd) != phdr[i].p_filesz))
 309         {
 310           eprintf (callback,
 311                    "%s: could not read segment at 0x%lx, size 0x%lx\n",
 312                    STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
 313           free (buf);
 314           return FALSE;
 315         }
 316
 317       if (do_write (sd, lma, buf, phdr[i].p_filesz) != phdr[i].p_filesz)
 318         {
 319           eprintf (callback,
 320                    "%s: could not load segment at 0x%lx, size 0x%lx\n",
 321                    STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
 322           free (buf);
 323           return FALSE;
 324         }
 325
 326       free (buf);
 327     }
 328
 329   return TRUE;
 330 }
 331
 332 /* Helper for sim_load (needed just for ELF files): like sim_write,
 333    but offset load at cris_program_offset offset.  */
 334
 335 static int
 336 cris_program_offset_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf,
 337                            int length)
 338 {
 339   return sim_write (sd, mem + cris_program_offset, buf, length);
 340 }
 341
 342 /* Replacement for ../common/sim-hload.c:sim_load, so we can treat ELF
 343    files differently.  */
 344
 345 SIM_RC
 346 sim_load (SIM_DESC sd, char *prog_name, struct bfd *prog_bfd,
 347           int from_tty ATTRIBUTE_UNUSED)
 348 {
 349   bfd *result_bfd;
 350
 351   if (bfd_get_flavour (prog_bfd) != bfd_target_elf_flavour)
 352     {
 353       SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 354       if (sim_analyze_program (sd, prog_name, prog_bfd) != SIM_RC_OK)
 355         return SIM_RC_FAIL;
 356       SIM_ASSERT (STATE_PROG_BFD (sd) != NULL);
 357
 358       result_bfd = sim_load_file (sd, STATE_MY_NAME (sd),
 359                                   STATE_CALLBACK (sd),
 360                                   prog_name,
 361                                   STATE_PROG_BFD (sd),
 362                                   STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG,
 363                                   STATE_LOAD_AT_LMA_P (sd),
 364                                   sim_write);
 365       if (result_bfd == NULL)
 366         {
 367           bfd_close (STATE_PROG_BFD (sd));
 368           STATE_PROG_BFD (sd) = NULL;
 369           return SIM_RC_FAIL;
 370         }
 371       return SIM_RC_OK;
 372     }
 373
 374   return cris_load_elf_file (sd, prog_bfd, cris_program_offset_write)
 375     ? SIM_RC_OK : SIM_RC_FAIL;
 376 }
 377
 378 /* Cover function of sim_state_free to free the cpu buffers as well.  */
 379
 380 static void
 381 free_state (SIM_DESC sd)
 382 {
 383   if (STATE_MODULES (sd) != NULL)
 384     sim_module_uninstall (sd);
 385   sim_cpu_free_all (sd);
 386   sim_state_free (sd);
 387 }
 388
 389 /* Helper struct for cris_set_section_offset_iterator.  */
 390
 391 struct offsetinfo
 392 {
 393   SIM_DESC sd;
 394   int offset;
 395 };
 396
 397 /* BFD section iterator to offset the LMA and VMA.  */
 398
 399 static void
 400 cris_set_section_offset_iterator (bfd *abfd, asection *s, void *vp)
 401 {
 402   struct offsetinfo *p = (struct offsetinfo *) vp;
 403   SIM_DESC sd = p->sd;
 404   int offset = p->offset;
 405
 406   if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
 407     {
 408       bfd_vma vma = bfd_get_section_vma (abfd, s);
 409
 410       bfd_set_section_vma (abfd, s, vma + offset);
 411     }
 412
 413   /* This seems clumsy and inaccurate, but let's stick to doing it the
 414      same way as sim_analyze_program for consistency.  */
 415   if (strcmp (bfd_get_section_name (abfd, s), ".text") == 0)
 416     STATE_TEXT_START (sd) = bfd_get_section_vma (abfd, s);
 417 }
 418
 419 /* Adjust the start-address, LMA and VMA of a SD.  Must be called
 420    after sim_analyze_program.  */
 421
 422 static void
 423 cris_offset_sections (SIM_DESC sd, int offset)
 424 {
 425   bfd_boolean ret;
 426   struct bfd *abfd = STATE_PROG_BFD (sd);
 427   asection *text;
 428   struct offsetinfo oi;
 429
 430   /* Only happens for usage error.  */
 431   if (abfd == NULL)
 432     return;
 433
 434   oi.sd = sd;
 435   oi.offset = offset;
 436
 437   bfd_map_over_sections (abfd, cris_set_section_offset_iterator, &oi);
 438   ret = bfd_set_start_address (abfd, bfd_get_start_address (abfd) + offset);
 439
 440   STATE_START_ADDR (sd) = bfd_get_start_address (abfd);
 441 }
 442
 443 /* BFD section iterator to find the highest and lowest allocated and
 444    non-allocated section addresses (plus one).  */
 445
 446 static void
 447 get_progbounds_iterator (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
 448 {
 449   struct progbounds *pbp = (struct progbounds *) vp;
 450
 451   if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
 452     {
 453       bfd_size_type sec_size = bfd_get_section_size (s);
 454       bfd_size_type sec_start = bfd_get_section_vma (abfd, s);
 455       bfd_size_type sec_end = sec_start + sec_size;
 456
 457       if (sec_end > pbp->endmem)
 458         pbp->endmem = sec_end;
 459
 460       if (sec_start < pbp->startmem)
 461         pbp->startmem = sec_start;
 462
 463       if ((bfd_get_section_flags (abfd, s) & SEC_LOAD))
 464         {
 465           if (sec_end > pbp->end_loadmem)
 466             pbp->end_loadmem = sec_end;
 467         }
 468       else if (sec_start < pbp->start_nonloadmem)
 469         pbp->start_nonloadmem = sec_start;
 470     }
 471 }
 472
 473 /* Get the program boundaries.  Because not everything is covered by
 474    sections in ELF, notably the program headers, we use the program
 475    headers instead.  */
 476
 477 static void
 478 cris_get_progbounds (struct bfd *abfd, struct progbounds *pbp)
 479 {
 480   Elf_Internal_Phdr *phdr;
 481   int n_hdrs;
 482   int i;
 483
 484   pbp->startmem = 0xffffffff;
 485   pbp->endmem = 0;
 486   pbp->end_loadmem = 0;
 487   pbp->start_nonloadmem = 0xffffffff;
 488
 489   /* In case we're ever used for something other than ELF, use the
 490      generic method.  */
 491   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
 492     {
 493       bfd_map_over_sections (abfd, get_progbounds_iterator, pbp);
 494       return;
 495     }
 496
 497   phdr = elf_tdata (abfd)->phdr;
 498   n_hdrs = elf_elfheader (abfd)->e_phnum;
 499
 500   /* We're only interested in PT_LOAD; all necessary information
 501      should be covered by that.  */
 502   for (i = 0; i < n_hdrs; i++)
 503     {
 504       if (phdr[i].p_type != PT_LOAD)
 505         continue;
 506
 507       if (phdr[i].p_paddr < pbp->startmem)
 508         pbp->startmem = phdr[i].p_paddr;
 509
 510       if (phdr[i].p_paddr + phdr[i].p_memsz > pbp->endmem)
 511         pbp->endmem = phdr[i].p_paddr + phdr[i].p_memsz;
 512
 513       if (phdr[i].p_paddr + phdr[i].p_filesz > pbp->end_loadmem)
 514         pbp->end_loadmem = phdr[i].p_paddr + phdr[i].p_filesz;
 515
 516       if (phdr[i].p_memsz > phdr[i].p_filesz
 517           && phdr[i].p_paddr + phdr[i].p_filesz < pbp->start_nonloadmem)
 518         pbp->start_nonloadmem = phdr[i].p_paddr + phdr[i].p_filesz;
 519     }
 520 }
 521
 522 /* Parameter communication by static variables, hmm...  Oh well, for
 523    simplicity.  */
 524 static bfd_vma exec_load_addr;
 525 static bfd_vma interp_load_addr;
 526 static bfd_vma interp_start_addr;
 527
 528 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)".  */
 529
 530 static USI
 531 aux_ent_phdr (struct bfd *ebfd)
 532 {
 533   return elf_elfheader (ebfd)->e_phoff + exec_load_addr;
 534 }
 535
 536 /* We just pass on the header info; we don't have our own idea of the
 537    program header entry size.  */
 538
 539 static USI
 540 aux_ent_phent (struct bfd *ebfd)
 541 {
 542   return elf_elfheader (ebfd)->e_phentsize;
 543 }
 544
 545 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)".  */
 546
 547 static USI
 548 aux_ent_phnum (struct bfd *ebfd)
 549 {
 550   return elf_elfheader (ebfd)->e_phnum;
 551 }
 552
 553 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)".  */
 554
 555 static USI
 556 aux_ent_base (struct bfd *ebfd)
 557 {
 558   return interp_load_addr;
 559 }
 560
 561 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)".  */
 562
 563 static USI
 564 aux_ent_entry (struct bfd *ebfd)
 565 {
 566   ASSERT (elf_elfheader (ebfd)->e_entry == bfd_get_start_address (ebfd));
 567   return elf_elfheader (ebfd)->e_entry;
 568 }
 569
 570 /* Helper for cris_handle_interpreter: like sim_write, but load at
 571    interp_load_addr offset.  */
 572
 573 static int
 574 cris_write_interp (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
 575 {
 576   return sim_write (sd, mem + interp_load_addr, buf, length);
 577 }
 578
 579 /* Cater to the presence of an interpreter: load it and set
 580    interp_start_addr.  Return FALSE if there was an error, TRUE if
 581    everything went fine, including an interpreter being absent and
 582    the program being in a non-ELF format.  */
 583
 584 static bfd_boolean
 585 cris_handle_interpreter (SIM_DESC sd, struct bfd *abfd)
 586 {
 587   int i, n_hdrs;
 588   bfd_vma phaddr;
 589   bfd_byte buf[4];
 590   char *interp = NULL;
 591   struct bfd *ibfd;
 592   bfd_boolean ok = FALSE;
 593   Elf_Internal_Phdr *phdr;
 594
 595   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
 596     return TRUE;
 597
 598   phdr = elf_tdata (abfd)->phdr;
 599   n_hdrs = aux_ent_phnum (abfd);
 600
 601   /* Check the program headers for presence of an interpreter.  */
 602   for (i = 0; i < n_hdrs; i++)
 603     {
 604       int interplen;
 605       bfd_size_type interpsiz, interp_filesiz;
 606       struct progbounds interp_bounds;
 607
 608       if (phdr[i].p_type != PT_INTERP)
 609         continue;
 610
 611       /* Get the name of the interpreter, prepended with the sysroot
 612          (empty if absent).  */
 613       interplen = phdr[i].p_filesz;
 614       interp = xmalloc (interplen + strlen (simulator_sysroot));
 615       strcpy (interp, simulator_sysroot);
 616
 617       /* Read in the name.  */
 618       if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
 619           || (bfd_bread (interp + strlen (simulator_sysroot), interplen, abfd)
 620               != interplen))
 621         goto interpname_failed;
 622
 623       /* Like Linux, require the string to be 0-terminated.  */
 624       if (interp[interplen + strlen (simulator_sysroot) - 1] != 0)
 625         goto interpname_failed;
 626
 627       /* Inspect the interpreter.  */
 628       ibfd = bfd_openr (interp, STATE_TARGET (sd));
 629       if (ibfd == NULL)
 630         goto interpname_failed;
 631
 632       /* The interpreter is at least something readable to BFD; make
 633          sure it's an ELF non-archive file.  */
 634       if (!bfd_check_format (ibfd, bfd_object)
 635           || bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
 636         goto interp_failed;
 637
 638       /* Check the layout of the interpreter.  */
 639       cris_get_progbounds (ibfd, &interp_bounds);
 640
 641       /* Round down to pagesize the start page and up the endpage.
 642          Don't round the *load and *nonload members.  */
 643       interp_bounds.startmem &= ~8191;
 644       interp_bounds.endmem = (interp_bounds.endmem + 8191) & ~8191;
 645
 646       /* Until we need a more dynamic solution, assume we can put the
 647          interpreter at this fixed location.  NB: this is not what
 648          happens for Linux 2008-12-28, but it could and might and
 649          perhaps should.  */
 650       interp_load_addr = 0x40000;
 651       interpsiz = interp_bounds.endmem - interp_bounds.startmem;
 652       interp_filesiz = interp_bounds.end_loadmem - interp_bounds.startmem;
 653
 654       /* If we have a non-DSO or interpreter starting at the wrong
 655          address, bail.  */
 656       if (interp_bounds.startmem != 0
 657           || interpsiz + interp_load_addr >= exec_load_addr)
 658         goto interp_failed;
 659
 660       /* We don't have the API to get the address of a simulator
 661          memory area, so we go via a temporary area.  Luckily, the
 662          interpreter is supposed to be small, less than 0x40000
 663          bytes.  */
 664       sim_do_commandf (sd, "memory region 0x%lx,0x%lx",
 665                        interp_load_addr, interpsiz);
 666
 667       /* Now that memory for the interpreter is defined, load it.  */
 668       if (!cris_load_elf_file (sd, ibfd, cris_write_interp))
 669         goto interp_failed;
 670
 671       /* It's no use setting STATE_START_ADDR, because it gets
 672          overwritten by a sim_analyze_program call in sim_load.  Let's
 673          just store it locally.  */
 674       interp_start_addr
 675         = (bfd_get_start_address (ibfd)
 676            - interp_bounds.startmem + interp_load_addr);
 677
 678       /* Linux cares only about the first PT_INTERP, so let's ignore
 679          the rest.  */
 680       goto all_done;
 681     }
 682
 683   /* Register R10 should hold 0 at static start (no finifunc), but
 684      that's the default, so don't bother.  */
 685   return TRUE;
 686
 687  all_done:
 688   ok = TRUE;
 689
 690  interp_failed:
 691   bfd_close (ibfd);
 692
 693  interpname_failed:
 694   if (!ok)
 695     sim_io_eprintf (sd,
 696                     "%s: could not load ELF interpreter `%s' for program `%s'\n",
 697                     STATE_MY_NAME (sd),
 698                     interp == NULL ? "(what's-its-name)" : interp,
 699                     bfd_get_filename (abfd));
 700   free (interp);
 701   return ok;
 702 }
 703
 704 /* Create an instance of the simulator.  */
 705
 706 SIM_DESC
 707 sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
 708           char **argv)
 709 {
 710   char c;
 711   int i;
 712   USI startmem = 0;
 713   USI endmem = CRIS_DEFAULT_MEM_SIZE;
 714   USI endbrk = endmem;
 715   USI stack_low = 0;
 716   SIM_DESC sd = sim_state_alloc (kind, callback);
 717
 718   static const struct auxv_entries_s
 719   {
 720     bfd_byte id;
 721     USI (*efn) (struct bfd *ebfd);
 722     USI val;
 723   } auxv_entries[] =
 724     {
 725 #define AUX_ENT(a, b) {a, NULL, b}
 726 #define AUX_ENTF(a, f) {a, f, 0}
 727       AUX_ENT (AT_HWCAP, 0),
 728       AUX_ENT (AT_PAGESZ, 8192),
 729       AUX_ENT (AT_CLKTCK, 100),
 730       AUX_ENTF (AT_PHDR, aux_ent_phdr),
 731       AUX_ENTF (AT_PHENT, aux_ent_phent),
 732       AUX_ENTF (AT_PHNUM, aux_ent_phnum),
 733       AUX_ENTF (AT_BASE, aux_ent_base),
 734       AUX_ENT (AT_FLAGS, 0),
 735       AUX_ENTF (AT_ENTRY, aux_ent_entry),
 736
 737       /* Or is root better?  Maybe have it settable?  */
 738       AUX_ENT (AT_UID, 500),
 739       AUX_ENT (AT_EUID, 500),
 740       AUX_ENT (AT_GID, 500),
 741       AUX_ENT (AT_EGID, 500),
 742       AUX_ENT (AT_SECURE, 0),
 743       AUX_ENT (AT_NULL, 0)
 744     };
 745
 746   /* Can't initialize to "" below.  It's either a GCC bug in old
 747      releases (up to and including 2.95.3 (.4 in debian) or a bug in the
 748      standard ;-) that the rest of the elements won't be initialized.  */
 749   bfd_byte sp_init[4] = {0, 0, 0, 0};
 750
 751   /* The cpu data is kept in a separately allocated chunk of memory.  */
 752   if (sim_cpu_alloc_all (sd, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK)
 753     {
 754       free_state (sd);
 755       return 0;
 756     }
 757
 758   if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
 759     {
 760       free_state (sd);
 761       return 0;
 762     }
 763
 764   /* getopt will print the error message so we just have to exit if this fails.
 765      FIXME: Hmmm...  in the case of gdb we need getopt to call
 766      print_filtered.  */
 767   if (sim_parse_args (sd, argv) != SIM_RC_OK)
 768     {
 769       free_state (sd);
 770       return 0;
 771     }
 772
 773   /* If we have a binary program, endianness-setting would not be taken
 774      from elsewhere unfortunately, so set it here.  At the time of this
 775      writing, it isn't used until sim_config, but that might change so
 776      set it here before memory is defined or touched.  */
 777   current_target_byte_order = LITTLE_ENDIAN;
 778
 779   /* check for/establish the reference program image */
 780   if (sim_analyze_program (sd,
 781                            (STATE_PROG_ARGV (sd) != NULL
 782                             ? *STATE_PROG_ARGV (sd)
 783                             : NULL),
 784                            abfd) != SIM_RC_OK)
 785     {
 786       /* When there's an error, sim_analyze_program has already output
 787          a message.  Let's just clarify it, as "not an object file"
 788          perhaps doesn't ring a bell.  */
 789       sim_io_eprintf (sd, "(not a CRIS program)\n");
 790       free_state (sd);
 791       return 0;
 792     }
 793
 794   /* We might get called with the caller expecting us to get hold of
 795      the bfd for ourselves, which would happen at the
 796      sim_analyze_program call above.  */
 797   if (abfd == NULL)
 798     abfd = STATE_PROG_BFD (sd);
 799
 800   /* Adjust the addresses of the program at this point.  Unfortunately
 801      this does not affect ELF program headers, so we have to handle
 802      that separately.  */
 803   cris_offset_sections (sd, cris_program_offset);
 804
 805   if (abfd != NULL && bfd_get_arch (abfd) == bfd_arch_unknown)
 806     {
 807       if (STATE_PROG_ARGV (sd) != NULL)
 808         sim_io_eprintf (sd, "%s: `%s' is not a CRIS program\n",
 809                         STATE_MY_NAME (sd), *STATE_PROG_ARGV (sd));
 810       else
 811         sim_io_eprintf (sd, "%s: program to be run is not a CRIS program\n",
 812                         STATE_MY_NAME (sd));
 813       free_state (sd);
 814       return 0;
 815     }
 816
 817   /* For CRIS simulator-specific use, we need to find out the bounds of
 818      the program as well, which is not done by sim_analyze_program
 819      above.  */
 820   if (abfd != NULL)
 821     {
 822       struct progbounds pb;
 823
 824       /* The sections should now be accessible using bfd functions.  */
 825       cris_get_progbounds (abfd, &pb);
 826
 827       /* We align the area that the program uses to page boundaries.  */
 828       startmem = pb.startmem & ~8191;
 829       endbrk = pb.endmem;
 830       endmem = (endbrk + 8191) & ~8191;
 831     }
 832
 833   /* Find out how much room is needed for the environment and argv, create
 834      that memory and fill it.  Only do this when there's a program
 835      specified.  */
 836   if (abfd != NULL && !cris_bare_iron)
 837     {
 838       char *name = bfd_get_filename (abfd);
 839       char **my_environ = GET_ENVIRON ();
 840       /* We use these maps to give the same behavior as the old xsim
 841          simulator.  */
 842       USI envtop = 0x40000000;
 843       USI stacktop = 0x3e000000;
 844       USI envstart;
 845       int envc;
 846       int len = strlen (name) + 1;
 847       USI epp, epp0;
 848       USI stacklen;
 849       int i;
 850       char **prog_argv = STATE_PROG_ARGV (sd);
 851       int my_argc = 0;
 852       /* All CPU:s have the same memory map, apparently.  */
 853       SIM_CPU *cpu = STATE_CPU (sd, 0);
 854       USI csp;
 855       bfd_byte buf[4];
 856
 857       /* Count in the environment as well. */
 858       for (envc = 0; my_environ[envc] != NULL; envc++)
 859         len += strlen (my_environ[envc]) + 1;
 860
 861       for (i = 0; prog_argv[i] != NULL; my_argc++, i++)
 862         len += strlen (prog_argv[i]) + 1;
 863
 864       envstart = (envtop - len) & ~8191;
 865
 866       /* Create read-only block for the environment strings.  */
 867       sim_core_attach (sd, NULL, 0, access_read, 0,
 868                        envstart, (len + 8191) & ~8191,
 869                        0, NULL, NULL);
 870
 871       /* This shouldn't happen.  */
 872       if (envstart < stacktop)
 873         stacktop = envstart - 64 * 8192;
 874
 875       csp = stacktop;
 876
 877       /* Note that the linux kernel does not correctly compute the storage
 878          needs for the static-exe AUX vector.  */
 879
 880       csp -= sizeof (auxv_entries) / sizeof (auxv_entries[0]) * 4 * 2;
 881
 882       csp -= (envc + 1) * 4;
 883       csp -= (my_argc + 1) * 4;
 884       csp -= 4;
 885
 886       /* Write the target representation of the start-up-value for the
 887          stack-pointer suitable for register initialization below.  */
 888       bfd_putl32 (csp, sp_init);
 889
 890       /* If we make this 1M higher; say 8192*1024, we have to take
 891          special precautions for pthreads, because pthreads assumes that
 892          the memory that low isn't mmapped, and that it can mmap it
 893          without fallback in case of failure (and we fail ungracefully
 894          long before *that*: the memory isn't accounted for in our mmap
 895          list).  */
 896       stack_low = (csp - (7168*1024)) & ~8191;
 897
 898       stacklen = stacktop - stack_low;
 899
 900       /* Tee hee, we have an executable stack.  Well, it's necessary to
 901          test GCC trampolines...  */
 902       sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
 903                        stack_low, stacklen,
 904                        0, NULL, NULL);
 905
 906       epp = epp0 = envstart;
 907
 908       /* Can't use sim_core_write_unaligned_4 without everything
 909          initialized when tracing, and then these writes would get into
 910          the trace.  */
 911 #define write_dword(addr, data)                                         \
 912  do                                                                     \
 913    {                                                                    \
 914      USI data_ = data;                                                  \
 915      USI addr_ = addr;                                                  \
 916      bfd_putl32 (data_, buf);                                           \
 917      if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4)        \
 918         goto abandon_chip;                                              \
 919    }                                                                    \
 920  while (0)
 921
 922       write_dword (csp, my_argc);
 923       csp += 4;
 924
 925       for (i = 0; i < my_argc; i++, csp += 4)
 926         {
 927           size_t strln = strlen (prog_argv[i]) + 1;
 928
 929           if (sim_core_write_buffer (sd, cpu, 0, prog_argv[i], epp, strln)
 930               != strln)
 931           goto abandon_chip;
 932
 933           write_dword (csp, envstart + epp - epp0);
 934           epp += strln;
 935         }
 936
 937       write_dword (csp, 0);
 938       csp += 4;
 939
 940       for (i = 0; i < envc; i++, csp += 4)
 941         {
 942           unsigned int strln = strlen (my_environ[i]) + 1;
 943
 944           if (sim_core_write_buffer (sd, cpu, 0, my_environ[i], epp, strln)
 945               != strln)
 946             goto abandon_chip;
 947
 948           write_dword (csp, envstart + epp - epp0);
 949           epp += strln;
 950         }
 951
 952       write_dword (csp, 0);
 953       csp += 4;
 954
 955       /* The load address of the executable could presumably be
 956          different than the lowest used memory address, but let's
 957          stick to simplicity until needed.  And
 958          cris_handle_interpreter might change startmem and endmem, so
 959          let's set it now.  */
 960       exec_load_addr = startmem;
 961
 962       if (!cris_handle_interpreter (sd, abfd))
 963         goto abandon_chip;
 964
 965       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 966         for (i = 0; i < sizeof (auxv_entries) / sizeof (auxv_entries[0]); i++)
 967           {
 968             write_dword (csp, auxv_entries[i].id);
 969             write_dword (csp + 4,
 970                          auxv_entries[i].efn != NULL
 971                          ? (*auxv_entries[i].efn) (abfd)
 972                          : auxv_entries[i].val);
 973             csp += 4 + 4;
 974           }
 975     }
 976
 977   /* Allocate core managed memory if none specified by user.  */
 978   if (sim_core_read_buffer (sd, NULL, read_map, &c, startmem, 1) == 0)
 979     sim_do_commandf (sd, "memory region 0x%lx,0x%lx", startmem,
 980                      endmem - startmem);
 981
 982   /* Allocate simulator I/O managed memory if none specified by user.  */
 983   if (cris_have_900000xxif)
 984     {
 985       if (sim_core_read_buffer (sd, NULL, read_map, &c, 0x90000000, 1) == 0)
 986         sim_core_attach (sd, NULL, 0, access_write, 0, 0x90000000, 0x100,
 987                          0, &cris_devices, NULL);
 988       else
 989         {
 990           (*callback->
 991            printf_filtered) (callback,
 992                              "Seeing --cris-900000xx with memory defined there\n");
 993           goto abandon_chip;
 994         }
 995     }
 996
 997   /* Establish any remaining configuration options.  */
 998   if (sim_config (sd) != SIM_RC_OK)
 999     {
1000     abandon_chip:
1001       free_state (sd);
1002       return 0;
1003     }
1004
1005   if (sim_post_argv_init (sd) != SIM_RC_OK)
1006     {
1007       free_state (sd);
1008       return 0;
1009     }
1010
1011   /* Open a copy of the cpu descriptor table.  */
1012   {
1013     CGEN_CPU_DESC cd = cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
1014                                              CGEN_ENDIAN_LITTLE);
1015     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
1016       {
1017         SIM_CPU *cpu = STATE_CPU (sd, i);
1018         CPU_CPU_DESC (cpu) = cd;
1019         CPU_DISASSEMBLER (cpu) = cris_disassemble_insn;
1020
1021         /* See cris_option_handler for the reason why this is needed.  */
1022         CPU_CRIS_MISC_PROFILE (cpu)->flags = STATE_TRACE_FLAGS (sd)[0];
1023
1024         /* Set SP to the stack we allocated above.  */
1025         (* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (char *) sp_init, 4);
1026
1027         /* Set the simulator environment data.  */
1028         cpu->highest_mmapped_page = NULL;
1029         cpu->endmem = endmem;
1030         cpu->endbrk = endbrk;
1031         cpu->stack_low = stack_low;
1032         cpu->syscalls = 0;
1033         cpu->m1threads = 0;
1034         cpu->threadno = 0;
1035         cpu->max_threadid = 0;
1036         cpu->thread_data = NULL;
1037         memset (cpu->sighandler, 0, sizeof (cpu->sighandler));
1038         cpu->make_thread_cpu_data = NULL;
1039         cpu->thread_cpu_data_size = 0;
1040 #if WITH_HW
1041         cpu->deliver_interrupt = NULL;
1042 #endif
1043       }
1044 #if WITH_HW
1045     /* Always be cycle-accurate and call before/after functions if
1046        with-hardware.  */
1047     sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
1048 #endif
1049   }
1050
1051   /* Initialize various cgen things not done by common framework.
1052      Must be done after cris_cgen_cpu_open.  */
1053   cgen_init (sd);
1054
1055   /* Store in a global so things like cris_dump_regs can be invoked
1056      from the gdb command line.  */
1057   current_state = sd;
1058
1059   cris_set_callbacks (callback);
1060
1061   return sd;
1062 }
1063
1064 void
1065 sim_close (SIM_DESC sd, int quitting ATTRIBUTE_UNUSED)
1066 {
1067   cris_cgen_cpu_close (CPU_CPU_DESC (STATE_CPU (sd, 0)));
1068   sim_module_uninstall (sd);
1069 }
1070 \f
1071 SIM_RC
1072 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
1073                      char **argv ATTRIBUTE_UNUSED,
1074                      char **envp ATTRIBUTE_UNUSED)
1075 {
1076   SIM_CPU *current_cpu = STATE_CPU (sd, 0);
1077   SIM_ADDR addr;
1078
1079   if (sd != NULL)
1080     addr = cris_start_address != (SIM_ADDR) -1
1081       ? cris_start_address
1082       : (interp_start_addr != 0
1083          ? interp_start_addr
1084          : bfd_get_start_address (abfd));
1085   else
1086     addr = 0;
1087   sim_pc_set (current_cpu, addr);
1088
1089   /* Other simulators have #if 0:d code that says
1090       STATE_ARGV (sd) = sim_copy_argv (argv);
1091       STATE_ENVP (sd) = sim_copy_argv (envp);
1092      Enabling that gives you not-found link-errors for sim_copy_argv.
1093      FIXME: Do archaeology to find out more.  */
1094
1095   return SIM_RC_OK;
1096 }
1097
1098 void
1099 sim_do_command (SIM_DESC sd, char *cmd)
1100 {
1101   if (sim_args_command (sd, cmd) != SIM_RC_OK)
1102     sim_io_eprintf (sd, "Unknown command `%s'\n", cmd);
1103 }
1104 \f
1105 /* Disassemble an instruction.  */
1106
1107 static void
1108 cris_disassemble_insn (SIM_CPU *cpu,
1109                        const CGEN_INSN *insn ATTRIBUTE_UNUSED,
1110                        const ARGBUF *abuf ATTRIBUTE_UNUSED,
1111                        IADDR pc, char *buf)
1112 {
1113   disassembler_ftype pinsn;
1114   struct disassemble_info disasm_info;
1115   SFILE sfile;
1116   SIM_DESC sd = CPU_STATE (cpu);
1117
1118   sfile.buffer = sfile.current = buf;
1119   INIT_DISASSEMBLE_INFO (disasm_info, (FILE *) &sfile,
1120                          (fprintf_ftype) sim_disasm_sprintf);
1121   disasm_info.endian = BFD_ENDIAN_LITTLE;
1122   disasm_info.read_memory_func = sim_disasm_read_memory;
1123   disasm_info.memory_error_func = sim_disasm_perror_memory;
1124   disasm_info.application_data = (PTR) cpu;
1125   pinsn = cris_get_disassembler (STATE_PROG_BFD (sd));
1126   (*pinsn) (pc, &disasm_info);
1127 }