sim/cris/sim-if.c

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