sim/bfin/interp.c

   1 /* Simulator for Analog Devices Blackfin processors.
   2
   3    Copyright (C) 2005-2012 Free Software Foundation, Inc.
   4    Contributed by Analog Devices, Inc.
   5
   6    This file is part of simulators.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <signal.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <sys/time.h>
  31
  32 #include "gdb/callback.h"
  33 #include "gdb/signals.h"
  34 #include "sim-main.h"
  35 #include "sim-hw.h"
  36
  37 #include "targ-vals.h"
  38
  39 /* The numbers here do not matter.  They just need to be unique.  */
  40 #define CB_SYS_ioctl        201
  41 #define CB_SYS_mmap2        202
  42 #define CB_SYS_munmap       203
  43 #define CB_SYS_dup2         204
  44 #define CB_SYS_getuid       205
  45 #define CB_SYS_getuid32     206
  46 #define CB_SYS_getgid       207
  47 #define CB_SYS_getgid32     208
  48 #define CB_SYS_setuid       209
  49 #define CB_SYS_setuid32     210
  50 #define CB_SYS_setgid       211
  51 #define CB_SYS_setgid32     212
  52 #define CB_SYS_pread        213
  53 #define CB_SYS__llseek      214
  54 #define CB_SYS_getcwd       215
  55 #define CB_SYS_stat64       216
  56 #define CB_SYS_lstat64      217
  57 #define CB_SYS_fstat64      218
  58 #define CB_SYS_ftruncate64  219
  59 #define CB_SYS_gettimeofday 220
  60 #define CB_SYS_access       221
  61 #include "linux-targ-map.h"
  62 #include "linux-fixed-code.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67 #include "elf/bfin.h"
  68 #include "elf-bfd.h"
  69
  70 #include "dv-bfin_cec.h"
  71 #include "dv-bfin_mmu.h"
  72
  73 #ifndef HAVE_GETUID
  74 # define getuid() 0
  75 #endif
  76 #ifndef HAVE_GETGID
  77 # define getgid() 0
  78 #endif
  79 #ifndef HAVE_GETEUID
  80 # define geteuid() 0
  81 #endif
  82 #ifndef HAVE_GETEGID
  83 # define getegid() 0
  84 #endif
  85 #ifndef HAVE_SETUID
  86 # define setuid(uid) -1
  87 #endif
  88 #ifndef HAVE_SETGID
  89 # define setgid(gid) -1
  90 #endif
  91
  92 static const char cb_linux_stat_map_32[] =
  93 /* Linux kernel 32bit layout:  */
  94 "st_dev,2:space,2:st_ino,4:st_mode,2:st_nlink,2:st_uid,2:st_gid,2:st_rdev,2:"
  95 "space,2:st_size,4:st_blksize,4:st_blocks,4:st_atime,4:st_atimensec,4:"
  96 "st_mtime,4:st_mtimensec,4:st_ctime,4:st_ctimensec,4:space,4:space,4";
  97 /* uClibc public ABI 32bit layout:
  98 "st_dev,8:space,2:space,2:st_ino,4:st_mode,4:st_nlink,4:st_uid,4:st_gid,4:"
  99 "st_rdev,8:space,2:space,2:st_size,4:st_blksiez,4:st_blocks,4:st_atime,4:"
 100 "st_atimensec,4:st_mtime,4:st_mtimensec,4:st_ctime,4:st_ctimensec,4:space,4:"
 101 "space,4";  */
 102 static const char cb_linux_stat_map_64[] =
 103 "st_dev,8:space,4:space,4:st_mode,4:st_nlink,4:st_uid,4:st_gid,4:st_rdev,8:"
 104 "space,4:st_size,8:st_blksize,4:st_blocks,8:st_atime,4:st_atimensec,4:"
 105 "st_mtime,4:st_mtimensec,4:st_ctime,4:st_ctimensec,4:st_ino,8";
 106 static const char cb_libgloss_stat_map_32[] =
 107 "st_dev,2:st_ino,2:st_mode,4:st_nlink,2:st_uid,2:st_gid,2:st_rdev,2:"
 108 "st_size,4:st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:"
 109 "space,4:st_blksize,4:st_blocks,4:space,8";
 110 static const char *stat_map_32, *stat_map_64;
 111
 112 /* Count the number of arguments in an argv.  */
 113 static int
 114 count_argc (const char * const *argv)
 115 {
 116   int i;
 117
 118   if (! argv)
 119     return -1;
 120
 121   for (i = 0; argv[i] != NULL; ++i)
 122     continue;
 123   return i;
 124 }
 125
 126 /* Read/write functions for system call interface.  */
 127
 128 static int
 129 syscall_read_mem (host_callback *cb, struct cb_syscall *sc,
 130                   unsigned long taddr, char *buf, int bytes)
 131 {
 132   SIM_DESC sd = (SIM_DESC) sc->p1;
 133   SIM_CPU *cpu = (SIM_CPU *) sc->p2;
 134
 135   MAYBE_TRACE (CORE, cpu, "DBUS FETCH (syscall) %i bytes @ 0x%08lx", bytes, taddr);
 136
 137   return sim_core_read_buffer (sd, cpu, read_map, buf, taddr, bytes);
 138 }
 139
 140 static int
 141 syscall_write_mem (host_callback *cb, struct cb_syscall *sc,
 142                   unsigned long taddr, const char *buf, int bytes)
 143 {
 144   SIM_DESC sd = (SIM_DESC) sc->p1;
 145   SIM_CPU *cpu = (SIM_CPU *) sc->p2;
 146
 147   MAYBE_TRACE (CORE, cpu, "DBUS STORE (syscall) %i bytes @ 0x%08lx", bytes, taddr);
 148
 149   return sim_core_write_buffer (sd, cpu, write_map, buf, taddr, bytes);
 150 }
 151
 152 /* Simulate a monitor trap, put the result into r0 and errno into r1
 153    return offset by which to adjust pc.  */
 154
 155 void
 156 bfin_syscall (SIM_CPU *cpu)
 157 {
 158   SIM_DESC sd = CPU_STATE (cpu);
 159   const char * const *argv = (void *)STATE_PROG_ARGV (sd);
 160   host_callback *cb = STATE_CALLBACK (sd);
 161   bu32 args[6];
 162   CB_SYSCALL sc;
 163   char *p;
 164   char _tbuf[1024 * 3], *tbuf = _tbuf, tstr[1024];
 165   int fmt_ret_hex = 0;
 166
 167   CB_SYSCALL_INIT (&sc);
 168
 169   if (STATE_ENVIRONMENT (sd) == USER_ENVIRONMENT)
 170     {
 171       /* Linux syscall.  */
 172       sc.func = PREG (0);
 173       sc.arg1 = args[0] = DREG (0);
 174       sc.arg2 = args[1] = DREG (1);
 175       sc.arg3 = args[2] = DREG (2);
 176       sc.arg4 = args[3] = DREG (3);
 177       /*sc.arg5 =*/ args[4] = DREG (4);
 178       /*sc.arg6 =*/ args[5] = DREG (5);
 179     }
 180   else
 181     {
 182       /* libgloss syscall.  */
 183       sc.func = PREG (0);
 184       sc.arg1 = args[0] = GET_LONG (DREG (0));
 185       sc.arg2 = args[1] = GET_LONG (DREG (0) + 4);
 186       sc.arg3 = args[2] = GET_LONG (DREG (0) + 8);
 187       sc.arg4 = args[3] = GET_LONG (DREG (0) + 12);
 188       /*sc.arg5 =*/ args[4] = GET_LONG (DREG (0) + 16);
 189       /*sc.arg6 =*/ args[5] = GET_LONG (DREG (0) + 20);
 190     }
 191   sc.p1 = (PTR) sd;
 192   sc.p2 = (PTR) cpu;
 193   sc.read_mem = syscall_read_mem;
 194   sc.write_mem = syscall_write_mem;
 195
 196   /* Common cb_syscall() handles most functions.  */
 197   switch (cb_target_to_host_syscall (cb, sc.func))
 198     {
 199     case CB_SYS_exit:
 200       tbuf += sprintf (tbuf, "exit(%i)", args[0]);
 201       sim_engine_halt (sd, cpu, NULL, PCREG, sim_exited, sc.arg1);
 202
 203 #ifdef CB_SYS_argc
 204     case CB_SYS_argc:
 205       tbuf += sprintf (tbuf, "argc()");
 206       sc.result = count_argc (argv);
 207       break;
 208     case CB_SYS_argnlen:
 209       {
 210       tbuf += sprintf (tbuf, "argnlen(%u)", args[0]);
 211         if (sc.arg1 < count_argc (argv))
 212           sc.result = strlen (argv[sc.arg1]);
 213         else
 214           sc.result = -1;
 215       }
 216       break;
 217     case CB_SYS_argn:
 218       {
 219         tbuf += sprintf (tbuf, "argn(%u)", args[0]);
 220         if (sc.arg1 < count_argc (argv))
 221           {
 222             const char *argn = argv[sc.arg1];
 223             int len = strlen (argn);
 224             int written = sc.write_mem (cb, &sc, sc.arg2, argn, len + 1);
 225             if (written == len + 1)
 226               sc.result = sc.arg2;
 227             else
 228               sc.result = -1;
 229           }
 230         else
 231           sc.result = -1;
 232       }
 233       break;
 234 #endif
 235
 236     case CB_SYS_gettimeofday:
 237       {
 238         struct timeval _tv, *tv = &_tv;
 239         struct timezone _tz, *tz = &_tz;
 240
 241         tbuf += sprintf (tbuf, "gettimeofday(%#x, %#x)", args[0], args[1]);
 242
 243         if (sc.arg1 == 0)
 244           tv = NULL;
 245         if (sc.arg2 == 0)
 246           tz = NULL;
 247         sc.result = gettimeofday (tv, tz);
 248
 249         if (sc.result == 0)
 250           {
 251             bu32 t;
 252
 253             if (tv)
 254               {
 255                 t = tv->tv_sec;
 256                 sc.write_mem (cb, &sc, sc.arg1, (void *)&t, 4);
 257                 t = tv->tv_usec;
 258                 sc.write_mem (cb, &sc, sc.arg1 + 4, (void *)&t, 4);
 259               }
 260
 261             if (sc.arg2)
 262               {
 263                 t = tz->tz_minuteswest;
 264                 sc.write_mem (cb, &sc, sc.arg1, (void *)&t, 4);
 265                 t = tz->tz_dsttime;
 266                 sc.write_mem (cb, &sc, sc.arg1 + 4, (void *)&t, 4);
 267               }
 268           }
 269         else
 270           goto sys_finish;
 271       }
 272       break;
 273
 274     case CB_SYS_ioctl:
 275       /* XXX: hack just enough to get basic stdio w/uClibc ...  */
 276       tbuf += sprintf (tbuf, "ioctl(%i, %#x, %u)", args[0], args[1], args[2]);
 277       if (sc.arg2 == 0x5401)
 278         {
 279           sc.result = !isatty (sc.arg1);
 280           sc.errcode = 0;
 281         }
 282       else
 283         {
 284           sc.result = -1;
 285           sc.errcode = TARGET_EINVAL;
 286         }
 287       break;
 288
 289     case CB_SYS_mmap2:
 290       {
 291         static bu32 heap = BFIN_DEFAULT_MEM_SIZE / 2;
 292
 293         fmt_ret_hex = 1;
 294         tbuf += sprintf (tbuf, "mmap2(%#x, %u, %#x, %#x, %i, %u)",
 295                          args[0], args[1], args[2], args[3], args[4], args[5]);
 296
 297         sc.errcode = 0;
 298
 299         if (sc.arg4 & 0x20 /*MAP_ANONYMOUS*/)
 300           /* XXX: We don't handle zeroing, but default is all zeros.  */;
 301         else if (args[4] >= MAX_CALLBACK_FDS)
 302           sc.errcode = TARGET_ENOSYS;
 303         else
 304           {
 305 #ifdef HAVE_PREAD
 306             char *data = xmalloc (sc.arg2);
 307
 308             /* XXX: Should add a cb->pread.  */
 309             if (pread (cb->fdmap[args[4]], data, sc.arg2, args[5] << 12) == sc.arg2)
 310               sc.write_mem (cb, &sc, heap, data, sc.arg2);
 311             else
 312               sc.errcode = TARGET_EINVAL;
 313
 314             free (data);
 315 #else
 316             sc.errcode = TARGET_ENOSYS;
 317 #endif
 318           }
 319
 320         if (sc.errcode)
 321           {
 322             sc.result = -1;
 323             break;
 324           }
 325
 326         sc.result = heap;
 327         heap += sc.arg2;
 328         /* Keep it page aligned.  */
 329         heap = ALIGN (heap, 4096);
 330
 331         break;
 332       }
 333
 334     case CB_SYS_munmap:
 335       /* XXX: meh, just lie for mmap().  */
 336       tbuf += sprintf (tbuf, "munmap(%#x, %u)", args[0], args[1]);
 337       sc.result = 0;
 338       break;
 339
 340     case CB_SYS_dup2:
 341       tbuf += sprintf (tbuf, "dup2(%i, %i)", args[0], args[1]);
 342       if (sc.arg1 >= MAX_CALLBACK_FDS || sc.arg2 >= MAX_CALLBACK_FDS)
 343         {
 344           sc.result = -1;
 345           sc.errcode = TARGET_EINVAL;
 346         }
 347       else
 348         {
 349           sc.result = dup2 (cb->fdmap[sc.arg1], cb->fdmap[sc.arg2]);
 350           goto sys_finish;
 351         }
 352       break;
 353
 354     case CB_SYS__llseek:
 355       tbuf += sprintf (tbuf, "llseek(%i, %u, %u, %#x, %u)",
 356                        args[0], args[1], args[2], args[3], args[4]);
 357       sc.func = TARGET_LINUX_SYS_lseek;
 358       if (sc.arg2)
 359         {
 360           sc.result = -1;
 361           sc.errcode = TARGET_EINVAL;
 362         }
 363       else
 364         {
 365           sc.arg2 = sc.arg3;
 366           sc.arg3 = args[4];
 367           cb_syscall (cb, &sc);
 368           if (sc.result != -1)
 369             {
 370               bu32 z = 0;
 371               sc.write_mem (cb, &sc, args[3], (void *)&sc.result, 4);
 372               sc.write_mem (cb, &sc, args[3] + 4, (void *)&z, 4);
 373             }
 374         }
 375       break;
 376
 377     /* XXX: Should add a cb->pread.  */
 378     case CB_SYS_pread:
 379       tbuf += sprintf (tbuf, "pread(%i, %#x, %u, %i)",
 380                        args[0], args[1], args[2], args[3]);
 381       if (sc.arg1 >= MAX_CALLBACK_FDS)
 382         {
 383           sc.result = -1;
 384           sc.errcode = TARGET_EINVAL;
 385         }
 386       else
 387         {
 388           long old_pos, read_result, read_errcode;
 389
 390           /* Get current filepos.  */
 391           sc.func = TARGET_LINUX_SYS_lseek;
 392           sc.arg2 = 0;
 393           sc.arg3 = SEEK_CUR;
 394           cb_syscall (cb, &sc);
 395           if (sc.result == -1)
 396             break;
 397           old_pos = sc.result;
 398
 399           /* Move to the new pos.  */
 400           sc.func = TARGET_LINUX_SYS_lseek;
 401           sc.arg2 = args[3];
 402           sc.arg3 = SEEK_SET;
 403           cb_syscall (cb, &sc);
 404           if (sc.result == -1)
 405             break;
 406
 407           /* Read the data.  */
 408           sc.func = TARGET_LINUX_SYS_read;
 409           sc.arg2 = args[1];
 410           sc.arg3 = args[2];
 411           cb_syscall (cb, &sc);
 412           read_result = sc.result;
 413           read_errcode = sc.errcode;
 414
 415           /* Move back to the old pos.  */
 416           sc.func = TARGET_LINUX_SYS_lseek;
 417           sc.arg2 = old_pos;
 418           sc.arg3 = SEEK_SET;
 419           cb_syscall (cb, &sc);
 420
 421           sc.result = read_result;
 422           sc.errcode = read_errcode;
 423         }
 424       break;
 425
 426     case CB_SYS_getcwd:
 427       tbuf += sprintf (tbuf, "getcwd(%#x, %u)", args[0], args[1]);
 428
 429       p = alloca (sc.arg2);
 430       if (getcwd (p, sc.arg2) == NULL)
 431         {
 432           sc.result = -1;
 433           sc.errcode = TARGET_EINVAL;
 434         }
 435       else
 436         {
 437           sc.write_mem (cb, &sc, sc.arg1, p, sc.arg2);
 438           sc.result = sc.arg1;
 439         }
 440       break;
 441
 442     case CB_SYS_stat64:
 443       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 444         strcpy (tstr, "???");
 445       tbuf += sprintf (tbuf, "stat64(%#x:\"%s\", %u)", args[0], tstr, args[1]);
 446       cb->stat_map = stat_map_64;
 447       sc.func = TARGET_LINUX_SYS_stat;
 448       cb_syscall (cb, &sc);
 449       cb->stat_map = stat_map_32;
 450       break;
 451     case CB_SYS_lstat64:
 452       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 453         strcpy (tstr, "???");
 454       tbuf += sprintf (tbuf, "lstat64(%#x:\"%s\", %u)", args[0], tstr, args[1]);
 455       cb->stat_map = stat_map_64;
 456       sc.func = TARGET_LINUX_SYS_lstat;
 457       cb_syscall (cb, &sc);
 458       cb->stat_map = stat_map_32;
 459       break;
 460     case CB_SYS_fstat64:
 461       tbuf += sprintf (tbuf, "fstat64(%#x, %u)", args[0], args[1]);
 462       cb->stat_map = stat_map_64;
 463       sc.func = TARGET_LINUX_SYS_fstat;
 464       cb_syscall (cb, &sc);
 465       cb->stat_map = stat_map_32;
 466       break;
 467
 468     case CB_SYS_ftruncate64:
 469       tbuf += sprintf (tbuf, "ftruncate64(%u, %u)", args[0], args[1]);
 470       sc.func = TARGET_LINUX_SYS_ftruncate;
 471       cb_syscall (cb, &sc);
 472       break;
 473
 474     case CB_SYS_getuid:
 475     case CB_SYS_getuid32:
 476       tbuf += sprintf (tbuf, "getuid()");
 477       sc.result = getuid ();
 478       goto sys_finish;
 479     case CB_SYS_getgid:
 480     case CB_SYS_getgid32:
 481       tbuf += sprintf (tbuf, "getgid()");
 482       sc.result = getgid ();
 483       goto sys_finish;
 484     case CB_SYS_setuid:
 485       sc.arg1 &= 0xffff;
 486     case CB_SYS_setuid32:
 487       tbuf += sprintf (tbuf, "setuid(%u)", args[0]);
 488       sc.result = setuid (sc.arg1);
 489       goto sys_finish;
 490     case CB_SYS_setgid:
 491       sc.arg1 &= 0xffff;
 492     case CB_SYS_setgid32:
 493       tbuf += sprintf (tbuf, "setgid(%u)", args[0]);
 494       sc.result = setgid (sc.arg1);
 495       goto sys_finish;
 496
 497     case CB_SYS_getpid:
 498       tbuf += sprintf (tbuf, "getpid()");
 499       sc.result = getpid ();
 500       goto sys_finish;
 501     case CB_SYS_kill:
 502       tbuf += sprintf (tbuf, "kill(%u, %i)", args[0], args[1]);
 503       /* Only let the app kill itself.  */
 504       if (sc.arg1 != getpid ())
 505         {
 506           sc.result = -1;
 507           sc.errcode = TARGET_EPERM;
 508         }
 509       else
 510         {
 511 #ifdef HAVE_KILL
 512           sc.result = kill (sc.arg1, sc.arg2);
 513           goto sys_finish;
 514 #else
 515           sc.result = -1;
 516           sc.errcode = TARGET_ENOSYS;
 517 #endif
 518         }
 519       break;
 520
 521     case CB_SYS_open:
 522       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 523         strcpy (tstr, "???");
 524       tbuf += sprintf (tbuf, "open(%#x:\"%s\", %#x, %o)",
 525                        args[0], tstr, args[1], args[2]);
 526       goto case_default;
 527     case CB_SYS_close:
 528       tbuf += sprintf (tbuf, "close(%i)", args[0]);
 529       goto case_default;
 530     case CB_SYS_read:
 531       tbuf += sprintf (tbuf, "read(%i, %#x, %u)", args[0], args[1], args[2]);
 532       goto case_default;
 533     case CB_SYS_write:
 534       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[1]))
 535         strcpy (tstr, "???");
 536       tbuf += sprintf (tbuf, "write(%i, %#x:\"%s\", %u)",
 537                        args[0], args[1], tstr, args[2]);
 538       goto case_default;
 539     case CB_SYS_lseek:
 540       tbuf += sprintf (tbuf, "lseek(%i, %i, %i)", args[0], args[1], args[2]);
 541       goto case_default;
 542     case CB_SYS_unlink:
 543       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 544         strcpy (tstr, "???");
 545       tbuf += sprintf (tbuf, "unlink(%#x:\"%s\")", args[0], tstr);
 546       goto case_default;
 547     case CB_SYS_truncate:
 548       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 549         strcpy (tstr, "???");
 550       tbuf += sprintf (tbuf, "truncate(%#x:\"%s\", %i)", args[0], tstr, args[1]);
 551       goto case_default;
 552     case CB_SYS_ftruncate:
 553       tbuf += sprintf (tbuf, "ftruncate(%i, %i)", args[0], args[1]);
 554       goto case_default;
 555     case CB_SYS_rename:
 556       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 557         strcpy (tstr, "???");
 558       tbuf += sprintf (tbuf, "rename(%#x:\"%s\", ", args[0], tstr);
 559       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[1]))
 560         strcpy (tstr, "???");
 561       tbuf += sprintf (tbuf, "%#x:\"%s\")", args[1], tstr);
 562       goto case_default;
 563     case CB_SYS_stat:
 564       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 565         strcpy (tstr, "???");
 566       tbuf += sprintf (tbuf, "stat(%#x:\"%s\", %#x)", args[0], tstr, args[1]);
 567       goto case_default;
 568     case CB_SYS_fstat:
 569       tbuf += sprintf (tbuf, "fstat(%i, %#x)", args[0], args[1]);
 570       goto case_default;
 571     case CB_SYS_lstat:
 572       if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
 573         strcpy (tstr, "???");
 574       tbuf += sprintf (tbuf, "lstat(%#x:\"%s\", %#x)", args[0], tstr, args[1]);
 575       goto case_default;
 576     case CB_SYS_pipe:
 577       tbuf += sprintf (tbuf, "pipe(%#x, %#x)", args[0], args[1]);
 578       goto case_default;
 579
 580     default:
 581       tbuf += sprintf (tbuf, "???_%i(%#x, %#x, %#x, %#x, %#x, %#x)", sc.func,
 582                        args[0], args[1], args[2], args[3], args[4], args[5]);
 583     case_default:
 584       cb_syscall (cb, &sc);
 585       break;
 586
 587     sys_finish:
 588       if (sc.result == -1)
 589         {
 590           cb->last_errno = errno;
 591           sc.errcode = cb->get_errno (cb);
 592         }
 593     }
 594
 595   TRACE_EVENTS (cpu, "syscall_%i(%#x, %#x, %#x, %#x, %#x, %#x) = %li (error = %i)",
 596                 sc.func, args[0], args[1], args[2], args[3], args[4], args[5],
 597                 sc.result, sc.errcode);
 598
 599   tbuf += sprintf (tbuf, " = ");
 600   if (STATE_ENVIRONMENT (sd) == USER_ENVIRONMENT)
 601     {
 602       if (sc.result == -1)
 603         {
 604           tbuf += sprintf (tbuf, "-1 (error = %i)", sc.errcode);
 605           if (sc.errcode == cb_host_to_target_errno (cb, ENOSYS))
 606             {
 607               sim_io_eprintf (sd, "bfin-sim: %#x: unimplemented syscall %i\n",
 608                               PCREG, sc.func);
 609             }
 610           SET_DREG (0, -sc.errcode);
 611         }
 612       else
 613         {
 614           if (fmt_ret_hex)
 615             tbuf += sprintf (tbuf, "%#lx", sc.result);
 616           else
 617             tbuf += sprintf (tbuf, "%lu", sc.result);
 618           SET_DREG (0, sc.result);
 619         }
 620     }
 621   else
 622     {
 623       tbuf += sprintf (tbuf, "%lu (error = %i)", sc.result, sc.errcode);
 624       SET_DREG (0, sc.result);
 625       SET_DREG (1, sc.result2);
 626       SET_DREG (2, sc.errcode);
 627     }
 628
 629   TRACE_SYSCALL (cpu, "%s", _tbuf);
 630 }
 631
 632 void
 633 trace_register (SIM_DESC sd,
 634                 sim_cpu *cpu,
 635                 const char *fmt,
 636                 ...)
 637 {
 638   va_list ap;
 639   trace_printf (sd, cpu, "%s %s",
 640                 "reg:     ",
 641                 TRACE_PREFIX (CPU_TRACE_DATA (cpu)));
 642   va_start (ap, fmt);
 643   trace_vprintf (sd, cpu, fmt, ap);
 644   va_end (ap);
 645   trace_printf (sd, cpu, "\n");
 646 }
 647
 648 /* Execute a single instruction.  */
 649
 650 static sim_cia
 651 step_once (SIM_CPU *cpu)
 652 {
 653   SIM_DESC sd = CPU_STATE (cpu);
 654   bu32 insn_len, oldpc = PCREG;
 655   int i;
 656   bool ssstep;
 657
 658   if (TRACE_ANY_P (cpu))
 659     trace_prefix (sd, cpu, NULL_CIA, oldpc, TRACE_LINENUM_P (cpu),
 660                   NULL, 0, " "); /* Use a space for gcc warnings.  */
 661
 662   /* Handle hardware single stepping when lower than EVT3, and when SYSCFG
 663      has already had the SSSTEP bit enabled.  */
 664   ssstep = false;
 665   if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT
 666       && (SYSCFGREG & SYSCFG_SSSTEP))
 667     {
 668       int ivg = cec_get_ivg (cpu);
 669       if (ivg == -1 || ivg > 3)
 670         ssstep = true;
 671     }
 672
 673 #if 0
 674   /* XXX: Is this what happens on the hardware ?  */
 675   if (cec_get_ivg (cpu) == EVT_EMU)
 676     cec_return (cpu, EVT_EMU);
 677 #endif
 678
 679   BFIN_CPU_STATE.did_jump = false;
 680
 681   insn_len = interp_insn_bfin (cpu, oldpc);
 682
 683   /* If we executed this insn successfully, then we always decrement
 684      the loop counter.  We don't want to update the PC though if the
 685      last insn happened to be a change in code flow (jump/etc...).  */
 686   if (!BFIN_CPU_STATE.did_jump)
 687     SET_PCREG (hwloop_get_next_pc (cpu, oldpc, insn_len));
 688   for (i = 1; i >= 0; --i)
 689     if (LCREG (i) && oldpc == LBREG (i))
 690       {
 691         SET_LCREG (i, LCREG (i) - 1);
 692         if (LCREG (i))
 693           break;
 694       }
 695
 696   ++ PROFILE_TOTAL_INSN_COUNT (CPU_PROFILE_DATA (cpu));
 697
 698   /* Handle hardware single stepping only if we're still lower than EVT3.
 699      XXX: May not be entirely correct wrt EXCPT insns.  */
 700   if (ssstep)
 701     {
 702       int ivg = cec_get_ivg (cpu);
 703       if (ivg == -1 || ivg > 3)
 704         {
 705           INSN_LEN = 0;
 706           cec_exception (cpu, VEC_STEP);
 707         }
 708     }
 709
 710   return oldpc;
 711 }
 712
 713 void
 714 sim_engine_run (SIM_DESC sd,
 715                 int next_cpu_nr, /* ignore  */
 716                 int nr_cpus, /* ignore  */
 717                 int siggnal) /* ignore  */
 718 {
 719   bu32 ticks;
 720   SIM_CPU *cpu;
 721
 722   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 723
 724   cpu = STATE_CPU (sd, 0);
 725
 726   while (1)
 727     {
 728       step_once (cpu);
 729       /* Process any events -- can't use tickn because it may
 730          advance right over the next event.  */
 731       for (ticks = 0; ticks < CYCLE_DELAY; ++ticks)
 732         if (sim_events_tick (sd))
 733           sim_events_process (sd);
 734     }
 735 }
 736
 737 /* Cover function of sim_state_free to free the cpu buffers as well.  */
 738
 739 static void
 740 free_state (SIM_DESC sd)
 741 {
 742   if (STATE_MODULES (sd) != NULL)
 743     sim_module_uninstall (sd);
 744   sim_cpu_free_all (sd);
 745   sim_state_free (sd);
 746 }
 747
 748 /* Create an instance of the simulator.  */
 749
 750 static void
 751 bfin_initialize_cpu (SIM_DESC sd, SIM_CPU *cpu)
 752 {
 753   memset (&cpu->state, 0, sizeof (cpu->state));
 754
 755   PROFILE_TOTAL_INSN_COUNT (CPU_PROFILE_DATA (cpu)) = 0;
 756
 757   bfin_model_cpu_init (sd, cpu);
 758
 759   /* Set default stack to top of scratch pad.  */
 760   SET_SPREG (BFIN_DEFAULT_MEM_SIZE);
 761   SET_KSPREG (BFIN_DEFAULT_MEM_SIZE);
 762   SET_USPREG (BFIN_DEFAULT_MEM_SIZE);
 763
 764   /* This is what the hardware likes.  */
 765   SET_SYSCFGREG (0x30);
 766 }
 767
 768 SIM_DESC
 769 sim_open (SIM_OPEN_KIND kind, host_callback *callback,
 770           struct bfd *abfd, char **argv)
 771 {
 772   char c;
 773   int i;
 774   SIM_DESC sd = sim_state_alloc (kind, callback);
 775
 776   /* The cpu data is kept in a separately allocated chunk of memory.  */
 777   if (sim_cpu_alloc_all (sd, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK)
 778     {
 779       free_state (sd);
 780       return 0;
 781     }
 782
 783   {
 784     /* XXX: Only first core gets profiled ?  */
 785     SIM_CPU *cpu = STATE_CPU (sd, 0);
 786     STATE_WATCHPOINTS (sd)->pc = &PCREG;
 787     STATE_WATCHPOINTS (sd)->sizeof_pc = sizeof (PCREG);
 788   }
 789
 790   if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
 791     {
 792       free_state (sd);
 793       return 0;
 794     }
 795
 796   /* XXX: Default to the Virtual environment.  */
 797   if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
 798     STATE_ENVIRONMENT (sd) = VIRTUAL_ENVIRONMENT;
 799
 800   /* These options override any module options.
 801      Obviously ambiguity should be avoided, however the caller may wish to
 802      augment the meaning of an option.  */
 803 #define e_sim_add_option_table(sd, options) \
 804   do { \
 805     extern const OPTION options[]; \
 806     sim_add_option_table (sd, NULL, options); \
 807   } while (0)
 808   e_sim_add_option_table (sd, bfin_mmu_options);
 809   e_sim_add_option_table (sd, bfin_mach_options);
 810
 811   /* getopt will print the error message so we just have to exit if this fails.
 812      FIXME: Hmmm...  in the case of gdb we need getopt to call
 813      print_filtered.  */
 814   if (sim_parse_args (sd, argv) != SIM_RC_OK)
 815     {
 816       free_state (sd);
 817       return 0;
 818     }
 819
 820   /* Allocate external memory if none specified by user.
 821      Use address 4 here in case the user wanted address 0 unmapped.  */
 822   if (sim_core_read_buffer (sd, NULL, read_map, &c, 4, 1) == 0)
 823     {
 824       bu16 emuexcpt = 0x25;
 825       sim_do_commandf (sd, "memory-size 0x%lx", BFIN_DEFAULT_MEM_SIZE);
 826       sim_write (sd, 0, (void *)&emuexcpt, 2);
 827     }
 828
 829   /* Check for/establish the a reference program image.  */
 830   if (sim_analyze_program (sd,
 831                            (STATE_PROG_ARGV (sd) != NULL
 832                             ? *STATE_PROG_ARGV (sd)
 833                             : NULL), abfd) != SIM_RC_OK)
 834     {
 835       free_state (sd);
 836       return 0;
 837     }
 838
 839   /* Establish any remaining configuration options.  */
 840   if (sim_config (sd) != SIM_RC_OK)
 841     {
 842       free_state (sd);
 843       return 0;
 844     }
 845
 846   if (sim_post_argv_init (sd) != SIM_RC_OK)
 847     {
 848       free_state (sd);
 849       return 0;
 850     }
 851
 852   /* CPU specific initialization.  */
 853   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 854     {
 855       SIM_CPU *cpu = STATE_CPU (sd, i);
 856       bfin_initialize_cpu (sd, cpu);
 857     }
 858
 859   return sd;
 860 }
 861
 862 void
 863 sim_close (SIM_DESC sd, int quitting)
 864 {
 865   sim_module_uninstall (sd);
 866 }
 867
 868 /* Some utils don't like having a NULL environ.  */
 869 static const char * const simple_env[] = { "HOME=/", "PATH=/bin", NULL };
 870
 871 static bu32 fdpic_load_offset;
 872
 873 static bool
 874 bfin_fdpic_load (SIM_DESC sd, SIM_CPU *cpu, struct bfd *abfd, bu32 *sp,
 875                  bu32 *elf_addrs, char **ldso_path)
 876 {
 877   bool ret;
 878   int i;
 879
 880   Elf_Internal_Ehdr *iehdr;
 881   Elf32_External_Ehdr ehdr;
 882   Elf_Internal_Phdr *phdrs;
 883   unsigned char *data;
 884   long phdr_size;
 885   int phdrc;
 886   bu32 nsegs;
 887
 888   bu32 max_load_addr;
 889
 890   unsigned char null[4] = { 0, 0, 0, 0 };
 891
 892   ret = false;
 893   *ldso_path = NULL;
 894
 895   /* See if this an FDPIC ELF.  */
 896   phdrs = NULL;
 897   if (!abfd)
 898     goto skip_fdpic_init;
 899   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 900     goto skip_fdpic_init;
 901   if (bfd_bread (&ehdr, sizeof (ehdr), abfd) != sizeof (ehdr))
 902     goto skip_fdpic_init;
 903   iehdr = elf_elfheader (abfd);
 904   if (!(iehdr->e_flags & EF_BFIN_FDPIC))
 905     goto skip_fdpic_init;
 906
 907   if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
 908     sim_io_printf (sd, "Loading FDPIC ELF %s\n Load base: %#x\n ELF entry: %#x\n",
 909                    bfd_get_filename (abfd), fdpic_load_offset, elf_addrs[0]);
 910
 911   /* Grab the Program Headers to set up the loadsegs on the stack.  */
 912   phdr_size = bfd_get_elf_phdr_upper_bound (abfd);
 913   if (phdr_size == -1)
 914     goto skip_fdpic_init;
 915   phdrs = xmalloc (phdr_size);
 916   phdrc = bfd_get_elf_phdrs (abfd, phdrs);
 917   if (phdrc == -1)
 918     goto skip_fdpic_init;
 919
 920   /* Push the Ehdr onto the stack.  */
 921   *sp -= sizeof (ehdr);
 922   elf_addrs[3] = *sp;
 923   sim_write (sd, *sp, (void *)&ehdr, sizeof (ehdr));
 924   if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
 925     sim_io_printf (sd, " Elf_Ehdr: %#x\n", *sp);
 926
 927   /* Since we're relocating things ourselves, we need to relocate
 928      the start address as well.  */
 929   elf_addrs[0] = bfd_get_start_address (abfd) + fdpic_load_offset;
 930
 931   /* And the Exec's Phdrs onto the stack.  */
 932   if (STATE_PROG_BFD (sd) == abfd)
 933     {
 934       elf_addrs[4] = elf_addrs[0];
 935
 936       phdr_size = iehdr->e_phentsize * iehdr->e_phnum;
 937       if (bfd_seek (abfd, iehdr->e_phoff, SEEK_SET) != 0)
 938         goto skip_fdpic_init;
 939       data = xmalloc (phdr_size);
 940       if (bfd_bread (data, phdr_size, abfd) != phdr_size)
 941         goto skip_fdpic_init;
 942       *sp -= phdr_size;
 943       elf_addrs[1] = *sp;
 944       elf_addrs[2] = phdrc;
 945       sim_write (sd, *sp, data, phdr_size);
 946       free (data);
 947       if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
 948         sim_io_printf (sd, " Elf_Phdrs: %#x\n", *sp);
 949     }
 950
 951   /* Now push all the loadsegs.  */
 952   nsegs = 0;
 953   max_load_addr = 0;
 954   for (i = phdrc; i >= 0; --i)
 955     if (phdrs[i].p_type == PT_LOAD)
 956       {
 957         Elf_Internal_Phdr *p = &phdrs[i];
 958         bu32 paddr, vaddr, memsz, filesz;
 959
 960         paddr = p->p_paddr + fdpic_load_offset;
 961         vaddr = p->p_vaddr;
 962         memsz = p->p_memsz;
 963         filesz = p->p_filesz;
 964
 965         if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
 966           sim_io_printf (sd, " PHDR %i: vma %#x lma %#x filesz %#x memsz %#x\n",
 967                          i, vaddr, paddr, filesz, memsz);
 968
 969         data = xmalloc (memsz);
 970         if (memsz != filesz)
 971           memset (data + filesz, 0, memsz - filesz);
 972
 973         if (bfd_seek (abfd, p->p_offset, SEEK_SET) == 0
 974             && bfd_bread (data, filesz, abfd) == filesz)
 975           sim_write (sd, paddr, data, memsz);
 976
 977         free (data);
 978
 979         max_load_addr = MAX (paddr + memsz, max_load_addr);
 980
 981         *sp -= 12;
 982         sim_write (sd, *sp+0, (void *)&paddr, 4); /* loadseg.addr  */
 983         sim_write (sd, *sp+4, (void *)&vaddr, 4); /* loadseg.p_vaddr  */
 984         sim_write (sd, *sp+8, (void *)&memsz, 4); /* loadseg.p_memsz  */
 985         ++nsegs;
 986       }
 987     else if (phdrs[i].p_type == PT_DYNAMIC)
 988       {
 989         elf_addrs[5] = phdrs[i].p_paddr + fdpic_load_offset;
 990         if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
 991           sim_io_printf (sd, " PT_DYNAMIC: %#x\n", elf_addrs[5]);
 992       }
 993     else if (phdrs[i].p_type == PT_INTERP)
 994       {
 995         uint32_t off = phdrs[i].p_offset;
 996         uint32_t len = phdrs[i].p_filesz;
 997
 998         *ldso_path = xmalloc (len);
 999         if (bfd_seek (abfd, off, SEEK_SET) != 0
1000             || bfd_bread (*ldso_path, len, abfd) != len)
1001           {
1002             free (*ldso_path);
1003             *ldso_path = NULL;
1004           }
1005         else if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
1006           sim_io_printf (sd, " PT_INTERP: %s\n", *ldso_path);
1007       }
1008
1009   /* Update the load offset with a few extra pages.  */
1010   fdpic_load_offset = ALIGN (MAX (max_load_addr, fdpic_load_offset), 0x10000);
1011   fdpic_load_offset += 0x10000;
1012
1013   /* Push the summary loadmap info onto the stack last.  */
1014   *sp -= 4;
1015   sim_write (sd, *sp+0, null, 2); /* loadmap.version  */
1016   sim_write (sd, *sp+2, (void *)&nsegs, 2); /* loadmap.nsegs  */
1017
1018   ret = true;
1019  skip_fdpic_init:
1020   free (phdrs);
1021
1022   return ret;
1023 }
1024
1025 static void
1026 bfin_user_init (SIM_DESC sd, SIM_CPU *cpu, struct bfd *abfd,
1027                 const char * const *argv, const char * const *env)
1028 {
1029   /* XXX: Missing host -> target endian ...  */
1030   /* Linux starts the user app with the stack:
1031        argc
1032        argv[0]          -- pointers to the actual strings
1033        argv[1..N]
1034        NULL
1035        env[0]
1036        env[1..N]
1037        NULL
1038        auxvt[0].type    -- ELF Auxiliary Vector Table
1039        auxvt[0].value
1040        auxvt[1..N]
1041        AT_NULL
1042        0
1043        argv[0..N][0..M] -- actual argv/env strings
1044        env[0..N][0..M]
1045        FDPIC loadmaps   -- for FDPIC apps
1046      So set things up the same way.  */
1047   int i, argc, envc;
1048   bu32 argv_flat, env_flat;
1049
1050   bu32 sp, sp_flat;
1051
1052   /* start, at_phdr, at_phnum, at_base, at_entry, pt_dynamic  */
1053   bu32 elf_addrs[6];
1054   bu32 auxvt, auxvt_size;
1055   bu32 exec_loadmap, ldso_loadmap;
1056   char *ldso_path;
1057
1058   unsigned char null[4] = { 0, 0, 0, 0 };
1059
1060   host_callback *cb = STATE_CALLBACK (sd);
1061
1062   elf_addrs[0] = elf_addrs[4] = bfd_get_start_address (abfd);
1063   elf_addrs[1] = elf_addrs[2] = elf_addrs[3] = elf_addrs[5] = 0;
1064
1065   /* Keep the load addresses consistent between runs.  Also make sure we make
1066      space for the fixed code region (part of the Blackfin Linux ABI).  */
1067   fdpic_load_offset = 0x1000;
1068
1069   /* First try to load this as an FDPIC executable.  */
1070   sp = SPREG;
1071   if (!bfin_fdpic_load (sd, cpu, STATE_PROG_BFD (sd), &sp, elf_addrs, &ldso_path))
1072     goto skip_fdpic_init;
1073   exec_loadmap = sp;
1074
1075   /* If that worked, then load the fixed code region.  We only do this for
1076      FDPIC ELFs atm because they are PIEs and let us relocate them without
1077      manual fixups.  FLAT files however require location processing which
1078      we do not do ourselves, and they link with a VMA of 0.  */
1079   sim_write (sd, 0x400, bfin_linux_fixed_code, sizeof (bfin_linux_fixed_code));
1080
1081   /* If the FDPIC needs an interpreter, then load it up too.  */
1082   if (ldso_path)
1083     {
1084       const char *ldso_full_path = concat (simulator_sysroot, ldso_path, NULL);
1085       struct bfd *ldso_bfd;
1086
1087       ldso_bfd = bfd_openr (ldso_full_path, STATE_TARGET (sd));
1088       if (!ldso_bfd)
1089         {
1090           sim_io_eprintf (sd, "bfin-sim: bfd open failed: %s\n", ldso_full_path);
1091           goto static_fdpic;
1092         }
1093       if (!bfd_check_format (ldso_bfd, bfd_object))
1094         sim_io_eprintf (sd, "bfin-sim: bfd format not valid: %s\n", ldso_full_path);
1095       bfd_set_arch_info (ldso_bfd, STATE_ARCHITECTURE (sd));
1096
1097       if (!bfin_fdpic_load (sd, cpu, ldso_bfd, &sp, elf_addrs, &ldso_path))
1098         sim_io_eprintf (sd, "bfin-sim: FDPIC ldso failed to load: %s\n", ldso_full_path);
1099       if (ldso_path)
1100         sim_io_eprintf (sd, "bfin-sim: FDPIC ldso (%s) needs an interpreter (%s) !?\n",
1101                         ldso_full_path, ldso_path);
1102
1103       ldso_loadmap = sp;
1104     }
1105   else
1106  static_fdpic:
1107     ldso_loadmap = 0;
1108
1109   /* Finally setup the registers required by the FDPIC ABI.  */
1110   SET_DREG (7, 0); /* Zero out FINI funcptr -- ldso will set this up.  */
1111   SET_PREG (0, exec_loadmap); /* Exec loadmap addr.  */
1112   SET_PREG (1, ldso_loadmap); /* Interp loadmap addr.  */
1113   SET_PREG (2, elf_addrs[5]); /* PT_DYNAMIC map addr.  */
1114
1115   auxvt = 1;
1116   SET_SPREG (sp);
1117  skip_fdpic_init:
1118   sim_pc_set (cpu, elf_addrs[0]);
1119
1120   /* Figure out how much storage the argv/env strings need.  */
1121   argc = count_argc (argv);
1122   if (argc == -1)
1123     argc = 0;
1124   argv_flat = argc; /* NUL bytes  */
1125   for (i = 0; i < argc; ++i)
1126     argv_flat += strlen (argv[i]);
1127
1128   if (!env)
1129     env = simple_env;
1130   envc = count_argc (env);
1131   env_flat = envc; /* NUL bytes  */
1132   for (i = 0; i < envc; ++i)
1133     env_flat += strlen (env[i]);
1134
1135   /* Push the Auxiliary Vector Table between argv/env and actual strings.  */
1136   sp_flat = sp = ALIGN (SPREG - argv_flat - env_flat - 4, 4);
1137   if (auxvt)
1138     {
1139 # define AT_PUSH(at, val) \
1140   auxvt_size += 8; \
1141   sp -= 4; \
1142   auxvt = (val); \
1143   sim_write (sd, sp, (void *)&auxvt, 4); \
1144   sp -= 4; \
1145   auxvt = (at); \
1146   sim_write (sd, sp, (void *)&auxvt, 4)
1147   auxvt_size = 0;
1148       unsigned int egid = getegid (), gid = getgid ();
1149       unsigned int euid = geteuid (), uid = getuid ();
1150       AT_PUSH (AT_NULL, 0);
1151       AT_PUSH (AT_SECURE, egid != gid || euid != uid);
1152       AT_PUSH (AT_EGID, egid);
1153       AT_PUSH (AT_GID, gid);
1154       AT_PUSH (AT_EUID, euid);
1155       AT_PUSH (AT_UID, uid);
1156       AT_PUSH (AT_ENTRY, elf_addrs[4]);
1157       AT_PUSH (AT_FLAGS, 0);
1158       AT_PUSH (AT_BASE, elf_addrs[3]);
1159       AT_PUSH (AT_PHNUM, elf_addrs[2]);
1160       AT_PUSH (AT_PHENT, sizeof (Elf32_External_Phdr));
1161       AT_PUSH (AT_PHDR, elf_addrs[1]);
1162       AT_PUSH (AT_CLKTCK, 100); /* XXX: This ever not 100 ?  */
1163       AT_PUSH (AT_PAGESZ, 4096);
1164       AT_PUSH (AT_HWCAP, 0);
1165 #undef AT_PUSH
1166     }
1167   SET_SPREG (sp);
1168
1169   /* Push the argc/argv/env after the auxvt.  */
1170   sp -= ((1 + argc + 1 + envc + 1) * 4);
1171   SET_SPREG (sp);
1172
1173   /* First push the argc value.  */
1174   sim_write (sd, sp, (void *)&argc, 4);
1175   sp += 4;
1176
1177   /* Then the actual argv strings so we know where to point argv[].  */
1178   for (i = 0; i < argc; ++i)
1179     {
1180       unsigned len = strlen (argv[i]) + 1;
1181       sim_write (sd, sp_flat, (void *)argv[i], len);
1182       sim_write (sd, sp, (void *)&sp_flat, 4);
1183       sp_flat += len;
1184       sp += 4;
1185     }
1186   sim_write (sd, sp, null, 4);
1187   sp += 4;
1188
1189   /* Then the actual env strings so we know where to point env[].  */
1190   for (i = 0; i < envc; ++i)
1191     {
1192       unsigned len = strlen (env[i]) + 1;
1193       sim_write (sd, sp_flat, (void *)env[i], len);
1194       sim_write (sd, sp, (void *)&sp_flat, 4);
1195       sp_flat += len;
1196       sp += 4;
1197     }
1198
1199   /* Set some callbacks.  */
1200   cb->syscall_map = cb_linux_syscall_map;
1201   cb->errno_map = cb_linux_errno_map;
1202   cb->open_map = cb_linux_open_map;
1203   cb->signal_map = cb_linux_signal_map;
1204   cb->stat_map = stat_map_32 = cb_linux_stat_map_32;
1205   stat_map_64 = cb_linux_stat_map_64;
1206 }
1207
1208 static void
1209 bfin_os_init (SIM_DESC sd, SIM_CPU *cpu, const char * const *argv)
1210 {
1211   /* Pass the command line via a string in R0 like Linux expects.  */
1212   int i;
1213   bu8 byte;
1214   bu32 cmdline = BFIN_L1_SRAM_SCRATCH;
1215
1216   SET_DREG (0, cmdline);
1217   if (argv && argv[0])
1218     {
1219       i = 1;
1220       byte = ' ';
1221       while (argv[i])
1222         {
1223           bu32 len = strlen (argv[i]);
1224           sim_write (sd, cmdline, (void *)argv[i], len);
1225           cmdline += len;
1226           sim_write (sd, cmdline, &byte, 1);
1227           ++cmdline;
1228           ++i;
1229         }
1230     }
1231   byte = 0;
1232   sim_write (sd, cmdline, &byte, 1);
1233 }
1234
1235 static void
1236 bfin_virtual_init (SIM_DESC sd, SIM_CPU *cpu)
1237 {
1238   host_callback *cb = STATE_CALLBACK (sd);
1239
1240   cb->stat_map = stat_map_32 = cb_libgloss_stat_map_32;
1241   stat_map_64 = NULL;
1242 }
1243
1244 SIM_RC
1245 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
1246                      char **argv, char **env)
1247 {
1248   SIM_CPU *cpu = STATE_CPU (sd, 0);
1249   SIM_ADDR addr;
1250
1251   /* Set the PC.  */
1252   if (abfd != NULL)
1253     addr = bfd_get_start_address (abfd);
1254   else
1255     addr = 0;
1256   sim_pc_set (cpu, addr);
1257
1258   /* Standalone mode (i.e. `bfin-...-run`) will take care of the argv
1259      for us in sim_open() -> sim_parse_args().  But in debug mode (i.e.
1260      'target sim' with `bfin-...-gdb`), we need to handle it.  */
1261   if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
1262     {
1263       freeargv (STATE_PROG_ARGV (sd));
1264       STATE_PROG_ARGV (sd) = dupargv (argv);
1265     }
1266
1267   switch (STATE_ENVIRONMENT (sd))
1268     {
1269     case USER_ENVIRONMENT:
1270       bfin_user_init (sd, cpu, abfd, (void *)argv, (void *)env);
1271       break;
1272     case OPERATING_ENVIRONMENT:
1273       bfin_os_init (sd, cpu, (void *)argv);
1274       break;
1275     default:
1276       bfin_virtual_init (sd, cpu);
1277       break;
1278     }
1279
1280   return SIM_RC_OK;
1281 }