sim/cris/traps.c

   1 /* CRIS exception, interrupt, and trap (EIT) support
   2    Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   3    Contributed by Axis Communications.
   4
   5 This file is part of the GNU simulators.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "sim-main.h"
  22 #include "sim-options.h"
  23 #include "bfd.h"
  24 /* FIXME: get rid of targ-vals.h usage everywhere else.  */
  25
  26 #ifdef HAVE_ERRNO_H
  27 #include <errno.h>
  28 #endif
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32 #ifdef HAVE_FCNTL_H
  33 #include <fcntl.h>
  34 #endif
  35 #ifdef HAVE_SYS_PARAM_H
  36 #include <sys/param.h>
  37 #endif
  38 #ifdef HAVE_SYS_STAT_H
  39 #include <sys/stat.h>
  40 #endif
  41
  42 /* The verbatim values are from asm-cris/unistd.h.  */
  43
  44 #define TARGET_SYS_exit 1
  45 #define TARGET_SYS_read 3
  46 #define TARGET_SYS_write 4
  47 #define TARGET_SYS_open 5
  48 #define TARGET_SYS_close 6
  49 #define TARGET_SYS_unlink 10
  50 #define TARGET_SYS_time 13
  51 #define TARGET_SYS_lseek 19
  52 #define TARGET_SYS_getpid 20
  53 #define TARGET_SYS_kill 37
  54 #define TARGET_SYS_rename 38
  55 #define TARGET_SYS_pipe 42
  56 #define TARGET_SYS_brk 45
  57 #define TARGET_SYS_ioctl 54
  58 #define TARGET_SYS_fcntl 55
  59 #define TARGET_SYS_getppid 64
  60 #define TARGET_SYS_setrlimit 75
  61 #define TARGET_SYS_gettimeofday  78
  62 #define TARGET_SYS_readlink 85
  63 #define TARGET_SYS_munmap 91
  64 #define TARGET_SYS_truncate 92
  65 #define TARGET_SYS_ftruncate 93
  66 #define TARGET_SYS_socketcall 102
  67 #define TARGET_SYS_stat 106
  68 #define TARGET_SYS_fstat 108
  69 #define TARGET_SYS_wait4 114
  70 #define TARGET_SYS_sigreturn 119
  71 #define TARGET_SYS_clone 120
  72 #define TARGET_SYS_uname 122
  73 #define TARGET_SYS_mprotect 125
  74 #define TARGET_SYS_llseek 140
  75 #define TARGET_SYS__sysctl 149
  76 #define TARGET_SYS_sched_setparam 154
  77 #define TARGET_SYS_sched_getparam 155
  78 #define TARGET_SYS_sched_setscheduler 156
  79 #define TARGET_SYS_sched_getscheduler 157
  80 #define TARGET_SYS_sched_yield 158
  81 #define TARGET_SYS_sched_get_priority_max 159
  82 #define TARGET_SYS_sched_get_priority_min 160
  83 #define TARGET_SYS_mremap 163
  84 #define TARGET_SYS_poll 168
  85 #define TARGET_SYS_rt_sigaction 174
  86 #define TARGET_SYS_rt_sigprocmask 175
  87 #define TARGET_SYS_rt_sigsuspend 179
  88 #define TARGET_SYS_getcwd 183
  89 #define TARGET_SYS_ugetrlimit 191
  90 #define TARGET_SYS_mmap2 192
  91 #define TARGET_SYS_stat64 195
  92 #define TARGET_SYS_lstat64 196
  93 #define TARGET_SYS_fstat64 197
  94 #define TARGET_SYS_geteuid32 201
  95 #define TARGET_SYS_getuid32 199
  96 #define TARGET_SYS_getegid32 202
  97 #define TARGET_SYS_getgid32 200
  98 #define TARGET_SYS_fcntl64 221
  99
 100 #define TARGET_PROT_READ        0x1
 101 #define TARGET_PROT_WRITE       0x2
 102 #define TARGET_PROT_EXEC        0x4
 103 #define TARGET_PROT_NONE        0x0
 104
 105 #define TARGET_MAP_SHARED       0x01
 106 #define TARGET_MAP_PRIVATE      0x02
 107 #define TARGET_MAP_TYPE         0x0f
 108 #define TARGET_MAP_FIXED        0x10
 109 #define TARGET_MAP_ANONYMOUS    0x20
 110
 111 #define TARGET_CTL_KERN         1
 112 #define TARGET_CTL_VM           2
 113 #define TARGET_CTL_NET          3
 114 #define TARGET_CTL_PROC         4
 115 #define TARGET_CTL_FS           5
 116 #define TARGET_CTL_DEBUG        6
 117 #define TARGET_CTL_DEV          7
 118 #define TARGET_CTL_BUS          8
 119 #define TARGET_CTL_ABI          9
 120
 121 #define TARGET_CTL_KERN_VERSION 4
 122
 123 /* linux/mman.h */
 124 #define TARGET_MREMAP_MAYMOVE  1
 125 #define TARGET_MREMAP_FIXED    2
 126
 127 #define TARGET_TCGETS 0x5401
 128
 129 #define TARGET_UTSNAME "#38 Sun Apr 1 00:00:00 MET 2001"
 130
 131 /* Seconds since the above date + 10 minutes.  */
 132 #define TARGET_EPOCH 986080200
 133
 134 /* Milliseconds since start of run.  We use the number of syscalls to
 135    avoid introducing noise in the execution time.  */
 136 #define TARGET_TIME_MS(cpu) ((cpu)->syscalls)
 137
 138 /* Seconds as in time(2).  */
 139 #define TARGET_TIME(cpu) (TARGET_EPOCH + TARGET_TIME_MS (cpu) / 1000)
 140
 141 #define TARGET_SCHED_OTHER 0
 142
 143 #define TARGET_RLIMIT_STACK 3
 144 #define TARGET_RLIMIT_NOFILE 7
 145
 146 #define SIM_TARGET_MAX_THREADS 64
 147 #define SIM_MAX_ALLOC_CHUNK (512*1024*1024)
 148
 149 /* From linux/sched.h.  */
 150 #define TARGET_CSIGNAL 0x000000ff
 151 #define TARGET_CLONE_VM 0x00000100
 152 #define TARGET_CLONE_FS 0x00000200
 153 #define TARGET_CLONE_FILES 0x00000400
 154 #define TARGET_CLONE_SIGHAND 0x00000800
 155 #define TARGET_CLONE_PID 0x00001000
 156 #define TARGET_CLONE_PTRACE 0x00002000
 157 #define TARGET_CLONE_VFORK 0x00004000
 158 #define TARGET_CLONE_PARENT 0x00008000
 159 #define TARGET_CLONE_THREAD 0x00010000
 160 #define TARGET_CLONE_SIGNAL (TARGET_CLONE_SIGHAND | TARGET_CLONE_THREAD)
 161
 162 /* From asm-cris/poll.h.  */
 163 #define TARGET_POLLIN 1
 164
 165 /* From asm-cris/signal.h.  */
 166 #define TARGET_SIG_BLOCK 0
 167 #define TARGET_SIG_UNBLOCK 1
 168 #define TARGET_SIG_SETMASK 2
 169
 170 #define TARGET_SIG_DFL 0
 171 #define TARGET_SIG_IGN 1
 172 #define TARGET_SIG_ERR ((USI)-1)
 173
 174 #define TARGET_SIGHUP 1
 175 #define TARGET_SIGINT 2
 176 #define TARGET_SIGQUIT 3
 177 #define TARGET_SIGILL 4
 178 #define TARGET_SIGTRAP 5
 179 #define TARGET_SIGABRT 6
 180 #define TARGET_SIGIOT 6
 181 #define TARGET_SIGBUS 7
 182 #define TARGET_SIGFPE 8
 183 #define TARGET_SIGKILL 9
 184 #define TARGET_SIGUSR1 10
 185 #define TARGET_SIGSEGV 11
 186 #define TARGET_SIGUSR2 12
 187 #define TARGET_SIGPIPE 13
 188 #define TARGET_SIGALRM 14
 189 #define TARGET_SIGTERM 15
 190 #define TARGET_SIGSTKFLT 16
 191 #define TARGET_SIGCHLD 17
 192 #define TARGET_SIGCONT 18
 193 #define TARGET_SIGSTOP 19
 194 #define TARGET_SIGTSTP 20
 195 #define TARGET_SIGTTIN 21
 196 #define TARGET_SIGTTOU 22
 197 #define TARGET_SIGURG 23
 198 #define TARGET_SIGXCPU 24
 199 #define TARGET_SIGXFSZ 25
 200 #define TARGET_SIGVTALRM 26
 201 #define TARGET_SIGPROF 27
 202 #define TARGET_SIGWINCH 28
 203 #define TARGET_SIGIO 29
 204 #define TARGET_SIGPOLL SIGIO
 205 /* Actually commented out in the kernel header.  */
 206 #define TARGET_SIGLOST 29
 207 #define TARGET_SIGPWR 30
 208 #define TARGET_SIGSYS 31
 209
 210 /* From include/asm-cris/signal.h.  */
 211 #define TARGET_SA_NOCLDSTOP 0x00000001
 212 #define TARGET_SA_NOCLDWAIT 0x00000002 /* not supported yet */
 213 #define TARGET_SA_SIGINFO 0x00000004
 214 #define TARGET_SA_ONSTACK 0x08000000
 215 #define TARGET_SA_RESTART 0x10000000
 216 #define TARGET_SA_NODEFER 0x40000000
 217 #define TARGET_SA_RESETHAND 0x80000000
 218 #define TARGET_SA_INTERRUPT 0x20000000 /* dummy -- ignored */
 219 #define TARGET_SA_RESTORER 0x04000000
 220
 221 /* From linux/wait.h.  */
 222 #define TARGET_WNOHANG 1
 223 #define TARGET_WUNTRACED 2
 224 #define TARGET___WNOTHREAD 0x20000000
 225 #define TARGET___WALL 0x40000000
 226 #define TARGET___WCLONE 0x80000000
 227
 228 static const char stat_map[] =
 229 "st_dev,2:space,10:space,4:st_mode,4:st_nlink,4:st_uid,4"
 230 ":st_gid,4:st_rdev,2:space,10:st_size,8:st_blksize,4:st_blocks,4"
 231 ":space,4:st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:space,4"
 232 ":st_ino,8";
 233
 234 static const CB_TARGET_DEFS_MAP syscall_map[] =
 235 {
 236   { CB_SYS_open, TARGET_SYS_open },
 237   { CB_SYS_close, TARGET_SYS_close },
 238   { CB_SYS_read, TARGET_SYS_read },
 239   { CB_SYS_write, TARGET_SYS_write },
 240   { CB_SYS_lseek, TARGET_SYS_lseek },
 241   { CB_SYS_unlink, TARGET_SYS_unlink },
 242   { CB_SYS_getpid, TARGET_SYS_getpid },
 243   { CB_SYS_fstat, TARGET_SYS_fstat64 },
 244   { CB_SYS_lstat, TARGET_SYS_lstat64 },
 245   { CB_SYS_stat, TARGET_SYS_stat64 },
 246   { CB_SYS_pipe, TARGET_SYS_pipe },
 247   { CB_SYS_rename, TARGET_SYS_rename },
 248   { CB_SYS_truncate, TARGET_SYS_truncate },
 249   { CB_SYS_ftruncate, TARGET_SYS_ftruncate },
 250   { 0, -1 }
 251 };
 252
 253 /* An older, 32-bit-only stat mapping.  */
 254 static const char stat32_map[] =
 255 "st_dev,2:space,2:st_ino,4:st_mode,2:st_nlink,2:st_uid,2"
 256 ":st_gid,2:st_rdev,2:space,2:st_size,4:st_blksize,4:st_blocks,4"
 257 ":st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:space,12";
 258
 259 /* Map for calls using the 32-bit struct stat.  Primarily used by the
 260    newlib Linux mapping.  */
 261 static const CB_TARGET_DEFS_MAP syscall_stat32_map[] =
 262 {
 263   { CB_SYS_fstat, TARGET_SYS_fstat },
 264   { CB_SYS_stat, TARGET_SYS_stat },
 265   { 0, -1 }
 266 };
 267
 268 /* Giving the true value for the running sim process will lead to
 269    non-time-invariant behavior.  */
 270 #define TARGET_PID 42
 271
 272 /* Unfortunately, we don't get this from cris.cpu at the moment, and if
 273    we did, we'd still don't get a register number with the "16" offset.  */
 274 #define TARGET_SRP_REGNUM (16+11)
 275
 276 /* Extracted by applying
 277    awk '/^#define/ { printf "#ifdef %s\n  { %s, %s },\n#endif\n", $2, $2, $3;}'
 278    on .../include/asm/errno.h in a GNU/Linux/CRIS installation and
 279    adjusting the synonyms.  */
 280
 281 static const CB_TARGET_DEFS_MAP errno_map[] =
 282 {
 283 #ifdef EPERM
 284   { EPERM, 1 },
 285 #endif
 286 #ifdef ENOENT
 287   { ENOENT, 2 },
 288 #endif
 289 #ifdef ESRCH
 290   { ESRCH, 3 },
 291 #endif
 292 #ifdef EINTR
 293   { EINTR, 4 },
 294 #endif
 295 #ifdef EIO
 296   { EIO, 5 },
 297 #endif
 298 #ifdef ENXIO
 299   { ENXIO, 6 },
 300 #endif
 301 #ifdef E2BIG
 302   { E2BIG, 7 },
 303 #endif
 304 #ifdef ENOEXEC
 305   { ENOEXEC, 8 },
 306 #endif
 307 #ifdef EBADF
 308   { EBADF, 9 },
 309 #endif
 310 #ifdef ECHILD
 311   { ECHILD, 10 },
 312 #endif
 313 #ifdef EAGAIN
 314   { EAGAIN, 11 },
 315 #endif
 316 #ifdef ENOMEM
 317   { ENOMEM, 12 },
 318 #endif
 319 #ifdef EACCES
 320   { EACCES, 13 },
 321 #endif
 322 #ifdef EFAULT
 323   { EFAULT, 14 },
 324 #endif
 325 #ifdef ENOTBLK
 326   { ENOTBLK, 15 },
 327 #endif
 328 #ifdef EBUSY
 329   { EBUSY, 16 },
 330 #endif
 331 #ifdef EEXIST
 332   { EEXIST, 17 },
 333 #endif
 334 #ifdef EXDEV
 335   { EXDEV, 18 },
 336 #endif
 337 #ifdef ENODEV
 338   { ENODEV, 19 },
 339 #endif
 340 #ifdef ENOTDIR
 341   { ENOTDIR, 20 },
 342 #endif
 343 #ifdef EISDIR
 344   { EISDIR, 21 },
 345 #endif
 346 #ifdef EINVAL
 347   { EINVAL, 22 },
 348 #endif
 349 #ifdef ENFILE
 350   { ENFILE, 23 },
 351 #endif
 352 #ifdef EMFILE
 353   { EMFILE, 24 },
 354 #endif
 355 #ifdef ENOTTY
 356   { ENOTTY, 25 },
 357 #endif
 358 #ifdef ETXTBSY
 359   { ETXTBSY, 26 },
 360 #endif
 361 #ifdef EFBIG
 362   { EFBIG, 27 },
 363 #endif
 364 #ifdef ENOSPC
 365   { ENOSPC, 28 },
 366 #endif
 367 #ifdef ESPIPE
 368   { ESPIPE, 29 },
 369 #endif
 370 #ifdef EROFS
 371   { EROFS, 30 },
 372 #endif
 373 #ifdef EMLINK
 374   { EMLINK, 31 },
 375 #endif
 376 #ifdef EPIPE
 377   { EPIPE, 32 },
 378 #endif
 379 #ifdef EDOM
 380   { EDOM, 33 },
 381 #endif
 382 #ifdef ERANGE
 383   { ERANGE, 34 },
 384 #endif
 385 #ifdef EDEADLK
 386   { EDEADLK, 35 },
 387 #endif
 388 #ifdef ENAMETOOLONG
 389   { ENAMETOOLONG, 36 },
 390 #endif
 391 #ifdef ENOLCK
 392   { ENOLCK, 37 },
 393 #endif
 394 #ifdef ENOSYS
 395   { ENOSYS, 38 },
 396 #endif
 397 #ifdef ENOTEMPTY
 398   { ENOTEMPTY, 39 },
 399 #endif
 400 #ifdef ELOOP
 401   { ELOOP, 40 },
 402 #endif
 403 #ifdef EWOULDBLOCK
 404   { EWOULDBLOCK, 11 },
 405 #endif
 406 #ifdef ENOMSG
 407   { ENOMSG, 42 },
 408 #endif
 409 #ifdef EIDRM
 410   { EIDRM, 43 },
 411 #endif
 412 #ifdef ECHRNG
 413   { ECHRNG, 44 },
 414 #endif
 415 #ifdef EL2NSYNC
 416   { EL2NSYNC, 45 },
 417 #endif
 418 #ifdef EL3HLT
 419   { EL3HLT, 46 },
 420 #endif
 421 #ifdef EL3RST
 422   { EL3RST, 47 },
 423 #endif
 424 #ifdef ELNRNG
 425   { ELNRNG, 48 },
 426 #endif
 427 #ifdef EUNATCH
 428   { EUNATCH, 49 },
 429 #endif
 430 #ifdef ENOCSI
 431   { ENOCSI, 50 },
 432 #endif
 433 #ifdef EL2HLT
 434   { EL2HLT, 51 },
 435 #endif
 436 #ifdef EBADE
 437   { EBADE, 52 },
 438 #endif
 439 #ifdef EBADR
 440   { EBADR, 53 },
 441 #endif
 442 #ifdef EXFULL
 443   { EXFULL, 54 },
 444 #endif
 445 #ifdef ENOANO
 446   { ENOANO, 55 },
 447 #endif
 448 #ifdef EBADRQC
 449   { EBADRQC, 56 },
 450 #endif
 451 #ifdef EBADSLT
 452   { EBADSLT, 57 },
 453 #endif
 454 #ifdef EDEADLOCK
 455   { EDEADLOCK, 35 },
 456 #endif
 457 #ifdef EBFONT
 458   { EBFONT, 59 },
 459 #endif
 460 #ifdef ENOSTR
 461   { ENOSTR, 60 },
 462 #endif
 463 #ifdef ENODATA
 464   { ENODATA, 61 },
 465 #endif
 466 #ifdef ETIME
 467   { ETIME, 62 },
 468 #endif
 469 #ifdef ENOSR
 470   { ENOSR, 63 },
 471 #endif
 472 #ifdef ENONET
 473   { ENONET, 64 },
 474 #endif
 475 #ifdef ENOPKG
 476   { ENOPKG, 65 },
 477 #endif
 478 #ifdef EREMOTE
 479   { EREMOTE, 66 },
 480 #endif
 481 #ifdef ENOLINK
 482   { ENOLINK, 67 },
 483 #endif
 484 #ifdef EADV
 485   { EADV, 68 },
 486 #endif
 487 #ifdef ESRMNT
 488   { ESRMNT, 69 },
 489 #endif
 490 #ifdef ECOMM
 491   { ECOMM, 70 },
 492 #endif
 493 #ifdef EPROTO
 494   { EPROTO, 71 },
 495 #endif
 496 #ifdef EMULTIHOP
 497   { EMULTIHOP, 72 },
 498 #endif
 499 #ifdef EDOTDOT
 500   { EDOTDOT, 73 },
 501 #endif
 502 #ifdef EBADMSG
 503   { EBADMSG, 74 },
 504 #endif
 505 #ifdef EOVERFLOW
 506   { EOVERFLOW, 75 },
 507 #endif
 508 #ifdef ENOTUNIQ
 509   { ENOTUNIQ, 76 },
 510 #endif
 511 #ifdef EBADFD
 512   { EBADFD, 77 },
 513 #endif
 514 #ifdef EREMCHG
 515   { EREMCHG, 78 },
 516 #endif
 517 #ifdef ELIBACC
 518   { ELIBACC, 79 },
 519 #endif
 520 #ifdef ELIBBAD
 521   { ELIBBAD, 80 },
 522 #endif
 523 #ifdef ELIBSCN
 524   { ELIBSCN, 81 },
 525 #endif
 526 #ifdef ELIBMAX
 527   { ELIBMAX, 82 },
 528 #endif
 529 #ifdef ELIBEXEC
 530   { ELIBEXEC, 83 },
 531 #endif
 532 #ifdef EILSEQ
 533   { EILSEQ, 84 },
 534 #endif
 535 #ifdef ERESTART
 536   { ERESTART, 85 },
 537 #endif
 538 #ifdef ESTRPIPE
 539   { ESTRPIPE, 86 },
 540 #endif
 541 #ifdef EUSERS
 542   { EUSERS, 87 },
 543 #endif
 544 #ifdef ENOTSOCK
 545   { ENOTSOCK, 88 },
 546 #endif
 547 #ifdef EDESTADDRREQ
 548   { EDESTADDRREQ, 89 },
 549 #endif
 550 #ifdef EMSGSIZE
 551   { EMSGSIZE, 90 },
 552 #endif
 553 #ifdef EPROTOTYPE
 554   { EPROTOTYPE, 91 },
 555 #endif
 556 #ifdef ENOPROTOOPT
 557   { ENOPROTOOPT, 92 },
 558 #endif
 559 #ifdef EPROTONOSUPPORT
 560   { EPROTONOSUPPORT, 93 },
 561 #endif
 562 #ifdef ESOCKTNOSUPPORT
 563   { ESOCKTNOSUPPORT, 94 },
 564 #endif
 565 #ifdef EOPNOTSUPP
 566   { EOPNOTSUPP, 95 },
 567 #endif
 568 #ifdef EPFNOSUPPORT
 569   { EPFNOSUPPORT, 96 },
 570 #endif
 571 #ifdef EAFNOSUPPORT
 572   { EAFNOSUPPORT, 97 },
 573 #endif
 574 #ifdef EADDRINUSE
 575   { EADDRINUSE, 98 },
 576 #endif
 577 #ifdef EADDRNOTAVAIL
 578   { EADDRNOTAVAIL, 99 },
 579 #endif
 580 #ifdef ENETDOWN
 581   { ENETDOWN, 100 },
 582 #endif
 583 #ifdef ENETUNREACH
 584   { ENETUNREACH, 101 },
 585 #endif
 586 #ifdef ENETRESET
 587   { ENETRESET, 102 },
 588 #endif
 589 #ifdef ECONNABORTED
 590   { ECONNABORTED, 103 },
 591 #endif
 592 #ifdef ECONNRESET
 593   { ECONNRESET, 104 },
 594 #endif
 595 #ifdef ENOBUFS
 596   { ENOBUFS, 105 },
 597 #endif
 598 #ifdef EISCONN
 599   { EISCONN, 106 },
 600 #endif
 601 #ifdef ENOTCONN
 602   { ENOTCONN, 107 },
 603 #endif
 604 #ifdef ESHUTDOWN
 605   { ESHUTDOWN, 108 },
 606 #endif
 607 #ifdef ETOOMANYREFS
 608   { ETOOMANYREFS, 109 },
 609 #endif
 610 #ifdef ETIMEDOUT
 611   { ETIMEDOUT, 110 },
 612 #endif
 613 #ifdef ECONNREFUSED
 614   { ECONNREFUSED, 111 },
 615 #endif
 616 #ifdef EHOSTDOWN
 617   { EHOSTDOWN, 112 },
 618 #endif
 619 #ifdef EHOSTUNREACH
 620   { EHOSTUNREACH, 113 },
 621 #endif
 622 #ifdef EALREADY
 623   { EALREADY, 114 },
 624 #endif
 625 #ifdef EINPROGRESS
 626   { EINPROGRESS, 115 },
 627 #endif
 628 #ifdef ESTALE
 629   { ESTALE, 116 },
 630 #endif
 631 #ifdef EUCLEAN
 632   { EUCLEAN, 117 },
 633 #endif
 634 #ifdef ENOTNAM
 635   { ENOTNAM, 118 },
 636 #endif
 637 #ifdef ENAVAIL
 638   { ENAVAIL, 119 },
 639 #endif
 640 #ifdef EISNAM
 641   { EISNAM, 120 },
 642 #endif
 643 #ifdef EREMOTEIO
 644   { EREMOTEIO, 121 },
 645 #endif
 646 #ifdef EDQUOT
 647   { EDQUOT, 122 },
 648 #endif
 649 #ifdef ENOMEDIUM
 650   { ENOMEDIUM, 123 },
 651 #endif
 652 #ifdef EMEDIUMTYPE
 653   { EMEDIUMTYPE, 124 },
 654 #endif
 655   { 0, -1 }
 656 };
 657
 658 /* Extracted by applying
 659    perl -ne 'if ($_ =~ /^#define/) { split;
 660      printf "#ifdef $_[1]\n  { %s, 0x%x },\n#endif\n",
 661              $_[1], $_[2] =~ /^0/ ? oct($_[2]) : $_[2];}'
 662    on pertinent parts of .../include/asm/fcntl.h in a GNU/Linux/CRIS
 663    installation and removing synonyms and unnecessary items.  Don't
 664    forget the end-marker.  */
 665
 666 /* These we treat specially, as they're used in the fcntl F_GETFL
 667    syscall.  For consistency, open_map is also manually edited to use
 668    these macros.  */
 669 #define TARGET_O_ACCMODE 0x3
 670 #define TARGET_O_RDONLY 0x0
 671 #define TARGET_O_WRONLY 0x1
 672
 673 static const CB_TARGET_DEFS_MAP open_map[] = {
 674 #ifdef O_ACCMODE
 675   { O_ACCMODE, TARGET_O_ACCMODE },
 676 #endif
 677 #ifdef O_RDONLY
 678   { O_RDONLY, TARGET_O_RDONLY },
 679 #endif
 680 #ifdef O_WRONLY
 681   { O_WRONLY, TARGET_O_WRONLY },
 682 #endif
 683 #ifdef O_RDWR
 684   { O_RDWR, 0x2 },
 685 #endif
 686 #ifdef O_CREAT
 687   { O_CREAT, 0x40 },
 688 #endif
 689 #ifdef O_EXCL
 690   { O_EXCL, 0x80 },
 691 #endif
 692 #ifdef O_NOCTTY
 693   { O_NOCTTY, 0x100 },
 694 #endif
 695 #ifdef O_TRUNC
 696   { O_TRUNC, 0x200 },
 697 #endif
 698 #ifdef O_APPEND
 699   { O_APPEND, 0x400 },
 700 #endif
 701 #ifdef O_NONBLOCK
 702   { O_NONBLOCK, 0x800 },
 703 #endif
 704 #ifdef O_NDELAY
 705   { O_NDELAY, 0x0 },
 706 #endif
 707 #ifdef O_SYNC
 708   { O_SYNC, 0x1000 },
 709 #endif
 710 #ifdef FASYNC
 711   { FASYNC, 0x2000 },
 712 #endif
 713 #ifdef O_DIRECT
 714   { O_DIRECT, 0x4000 },
 715 #endif
 716 #ifdef O_LARGEFILE
 717   { O_LARGEFILE, 0x8000 },
 718 #endif
 719 #ifdef O_DIRECTORY
 720   { O_DIRECTORY, 0x10000 },
 721 #endif
 722 #ifdef O_NOFOLLOW
 723   { O_NOFOLLOW, 0x20000 },
 724 #endif
 725   { -1, -1 }
 726 };
 727
 728 /* Needed for the cris_pipe_nonempty and cris_pipe_empty syscalls.  */
 729 static SIM_CPU *current_cpu_for_cb_callback;
 730
 731 static int syscall_read_mem (host_callback *, struct cb_syscall *,
 732                              unsigned long, char *, int);
 733 static int syscall_write_mem (host_callback *, struct cb_syscall *,
 734                               unsigned long, const char *, int);
 735 static USI create_map (SIM_DESC, struct cris_sim_mmapped_page **,
 736                        USI addr, USI len);
 737 static USI unmap_pages (SIM_DESC, struct cris_sim_mmapped_page **,
 738                        USI addr, USI len);
 739 static USI is_mapped (SIM_DESC, struct cris_sim_mmapped_page **,
 740                        USI addr, USI len);
 741 static void dump_statistics (SIM_CPU *current_cpu);
 742 static void make_first_thread (SIM_CPU *current_cpu);
 743
 744 /* Read/write functions for system call interface.  */
 745
 746 static int
 747 syscall_read_mem (host_callback *cb ATTRIBUTE_UNUSED,
 748                   struct cb_syscall *sc,
 749                   unsigned long taddr, char *buf, int bytes)
 750 {
 751   SIM_DESC sd = (SIM_DESC) sc->p1;
 752   SIM_CPU *cpu = (SIM_CPU *) sc->p2;
 753
 754   return sim_core_read_buffer (sd, cpu, read_map, buf, taddr, bytes);
 755 }
 756
 757 static int
 758 syscall_write_mem (host_callback *cb ATTRIBUTE_UNUSED,
 759                    struct cb_syscall *sc,
 760                    unsigned long taddr, const char *buf, int bytes)
 761 {
 762   SIM_DESC sd = (SIM_DESC) sc->p1;
 763   SIM_CPU *cpu = (SIM_CPU *) sc->p2;
 764
 765   return sim_core_write_buffer (sd, cpu, write_map, buf, taddr, bytes);
 766 }
 767
 768 /* When we risk running self-modified code (as in trampolines), this is
 769    called from special-case insns.  The silicon CRIS CPU:s have enough
 770    cache snooping implemented making this a simulator-only issue.  Tests:
 771    gcc.c-torture/execute/931002-1.c execution, -O3 -g
 772    gcc.c-torture/execute/931002-1.c execution, -O3 -fomit-frame-pointer.  */
 773
 774 void
 775 cris_flush_simulator_decode_cache (SIM_CPU *current_cpu,
 776                                    USI pc ATTRIBUTE_UNUSED)
 777 {
 778   SIM_DESC sd = CPU_STATE (current_cpu);
 779
 780 #if WITH_SCACHE
 781   if (USING_SCACHE_P (sd))
 782     scache_flush_cpu (current_cpu);
 783 #endif
 784 }
 785
 786 /* Output statistics at the end of a run.  */
 787 static void
 788 dump_statistics (SIM_CPU *current_cpu)
 789 {
 790   SIM_DESC sd = CPU_STATE (current_cpu);
 791   CRIS_MISC_PROFILE *profp
 792     = CPU_CRIS_MISC_PROFILE (current_cpu);
 793   unsigned64 total = profp->basic_cycle_count;
 794   const char *textmsg = "Basic clock cycles, total @: %llu\n";
 795
 796   /* The --cris-stats={basic|unaligned|schedulable|all} counts affect
 797      what's included in the "total" count only.  */
 798   switch (CPU_CRIS_MISC_PROFILE (current_cpu)->flags
 799           & FLAG_CRIS_MISC_PROFILE_ALL)
 800     {
 801     case FLAG_CRIS_MISC_PROFILE_SIMPLE:
 802       break;
 803
 804     case (FLAG_CRIS_MISC_PROFILE_UNALIGNED | FLAG_CRIS_MISC_PROFILE_SIMPLE):
 805       textmsg
 806         = "Clock cycles including stall cycles for unaligned accesses @: %llu\n";
 807       total += profp->unaligned_mem_dword_count;
 808       break;
 809
 810     case (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE | FLAG_CRIS_MISC_PROFILE_SIMPLE):
 811       textmsg = "Schedulable clock cycles, total @: %llu\n";
 812       total
 813         += (profp->memsrc_stall_count
 814             + profp->memraw_stall_count
 815             + profp->movemsrc_stall_count
 816             + profp->movemdst_stall_count
 817             + profp->mulsrc_stall_count
 818             + profp->jumpsrc_stall_count
 819             + profp->unaligned_mem_dword_count);
 820       break;
 821
 822     case FLAG_CRIS_MISC_PROFILE_ALL:
 823       textmsg = "All accounted clock cycles, total @: %llu\n";
 824       total
 825         += (profp->memsrc_stall_count
 826             + profp->memraw_stall_count
 827             + profp->movemsrc_stall_count
 828             + profp->movemdst_stall_count
 829             + profp->movemaddr_stall_count
 830             + profp->mulsrc_stall_count
 831             + profp->jumpsrc_stall_count
 832             + profp->branch_stall_count
 833             + profp->jumptarget_stall_count
 834             + profp->unaligned_mem_dword_count);
 835       break;
 836
 837     default:
 838       abort ();
 839
 840       sim_io_eprintf (sd,
 841                       "Internal inconsistency at %s:%d",
 842                       __FILE__, __LINE__);
 843       sim_engine_halt (sd, current_cpu, NULL, 0,
 844                        sim_stopped, SIM_SIGILL);
 845     }
 846
 847   /* Historically, these messages have gone to stderr, so we'll keep it
 848      that way.  It's also easier to then tell it from normal program
 849      output.  FIXME: Add redirect option like "run -e file".  */
 850   sim_io_eprintf (sd, textmsg, total);
 851
 852   /* For v32, unaligned_mem_dword_count should always be 0.  For
 853      v10, memsrc_stall_count should always be 0.  */
 854   sim_io_eprintf (sd, "Memory source stall cycles: %lld\n",
 855                   profp->memsrc_stall_count
 856                   + profp->unaligned_mem_dword_count);
 857   sim_io_eprintf (sd, "Memory read-after-write stall cycles: %lld\n",
 858                   profp->memraw_stall_count);
 859   sim_io_eprintf (sd, "Movem source stall cycles: %lld\n",
 860                   profp->movemsrc_stall_count);
 861   sim_io_eprintf (sd, "Movem destination stall cycles: %lld\n",
 862                   profp->movemdst_stall_count);
 863   sim_io_eprintf (sd, "Movem address stall cycles: %lld\n",
 864                   profp->movemaddr_stall_count);
 865   sim_io_eprintf (sd, "Multiplication source stall cycles: %lld\n",
 866                   profp->mulsrc_stall_count);
 867   sim_io_eprintf (sd, "Jump source stall cycles: %lld\n",
 868                   profp->jumpsrc_stall_count);
 869   sim_io_eprintf (sd, "Branch misprediction stall cycles: %lld\n",
 870                   profp->branch_stall_count);
 871   sim_io_eprintf (sd, "Jump target stall cycles: %lld\n",
 872                   profp->jumptarget_stall_count);
 873 }
 874
 875 /* Check whether any part of [addr .. addr + len - 1] is already mapped.
 876    Return 1 if a overlap detected, 0 otherwise.  */
 877
 878 static USI
 879 is_mapped (SIM_DESC sd ATTRIBUTE_UNUSED,
 880            struct cris_sim_mmapped_page **rootp,
 881            USI addr, USI len)
 882 {
 883   struct cris_sim_mmapped_page *mapp;
 884
 885   if (len == 0 || (len & 8191))
 886     abort ();
 887
 888   /* Iterate over the reverse-address sorted pages until we find a page in
 889      or lower than the checked area.  */
 890   for (mapp = *rootp; mapp != NULL && mapp->addr >= addr; mapp = mapp->prev)
 891     if (mapp->addr < addr + len && mapp->addr >= addr)
 892       return 1;
 893
 894   return 0;
 895 }
 896
 897 /* Create mmapped memory.  */
 898
 899 static USI
 900 create_map (SIM_DESC sd, struct cris_sim_mmapped_page **rootp, USI addr,
 901             USI len)
 902 {
 903   struct cris_sim_mmapped_page *mapp;
 904   struct cris_sim_mmapped_page **higher_prevp = rootp;
 905   USI new_addr = 0x40000000;
 906
 907   if (addr != 0)
 908     new_addr = addr;
 909   else if (*rootp)
 910     new_addr = rootp[0]->addr + 8192;
 911
 912   if (len != 8192)
 913     {
 914       USI page_addr;
 915
 916       if (len & 8191)
 917         /* Which is better: return an error for this, or just round it up?  */
 918         abort ();
 919
 920       /* Do a recursive call for each page in the request.  */
 921       for (page_addr = new_addr; len != 0; page_addr += 8192, len -= 8192)
 922         if (create_map (sd, rootp, page_addr, 8192) >= (USI) -8191)
 923           abort ();
 924
 925       return new_addr;
 926     }
 927
 928   for (mapp = *rootp;
 929        mapp != NULL && mapp->addr > new_addr;
 930        mapp = mapp->prev)
 931     higher_prevp = &mapp->prev;
 932
 933   /* Allocate the new page, on the next higher page from the last one
 934      allocated, and link in the new descriptor before previous ones.  */
 935   mapp = malloc (sizeof (*mapp));
 936
 937   if (mapp == NULL)
 938     return (USI) -ENOMEM;
 939
 940   sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
 941                    new_addr, len,
 942                    0, NULL, NULL);
 943
 944   mapp->addr = new_addr;
 945   mapp->prev = *higher_prevp;
 946   *higher_prevp = mapp;
 947
 948   return new_addr;
 949 }
 950
 951 /* Unmap one or more pages.  */
 952
 953 static USI
 954 unmap_pages (SIM_DESC sd, struct cris_sim_mmapped_page **rootp, USI addr,
 955             USI len)
 956 {
 957   struct cris_sim_mmapped_page *mapp;
 958   struct cris_sim_mmapped_page **higher_prevp = rootp;
 959
 960   if (len != 8192)
 961     {
 962       USI page_addr;
 963
 964       if (len & 8191)
 965         /* Which is better: return an error for this, or just round it up?  */
 966         abort ();
 967
 968       /* Loop backwards to make each call is O(1) over the number of pages
 969          allocated, if we're unmapping from the high end of the pages.  */
 970       for (page_addr = addr + len - 8192;
 971            page_addr >= addr;
 972            page_addr -= 8192)
 973         if (unmap_pages (sd, rootp, page_addr, 8192) != 0)
 974           abort ();
 975
 976       return 0;
 977     }
 978
 979   for (mapp = *rootp; mapp != NULL && mapp->addr > addr; mapp = mapp->prev)
 980     higher_prevp = &mapp->prev;
 981
 982   if (mapp == NULL || mapp->addr != addr)
 983     return EINVAL;
 984
 985   *higher_prevp = mapp->prev;
 986   sim_core_detach (sd, NULL, 0, 0, addr);
 987   free (mapp);
 988   return 0;
 989 }
 990
 991 /* The semantic code invokes this for illegal (unrecognized) instructions.  */
 992
 993 SEM_PC
 994 sim_engine_invalid_insn (SIM_CPU *current_cpu, IADDR cia, SEM_PC vpc)
 995 {
 996   SIM_DESC sd = CPU_STATE (current_cpu);
 997
 998   sim_engine_halt (sd, current_cpu, NULL, cia, sim_stopped, SIM_SIGILL);
 999   return vpc;
1000 }
1001
1002 /* Handlers from the CGEN description that should not be called.  */
1003
1004 USI
1005 cris_bmod_handler (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
1006                    UINT srcreg ATTRIBUTE_UNUSED,
1007                    USI dstreg ATTRIBUTE_UNUSED)
1008 {
1009   abort ();
1010 }
1011
1012 void
1013 h_supr_set_handler (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
1014                     UINT index ATTRIBUTE_UNUSED,
1015                     USI page ATTRIBUTE_UNUSED,
1016                     USI newval ATTRIBUTE_UNUSED)
1017 {
1018   abort ();
1019 }
1020
1021 USI
1022 h_supr_get_handler (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
1023                     UINT index ATTRIBUTE_UNUSED,
1024                     USI page ATTRIBUTE_UNUSED)
1025 {
1026   abort ();
1027 }
1028
1029 /* Swap one context for another.  */
1030
1031 static void
1032 schedule (SIM_CPU *current_cpu, int next)
1033 {
1034   /* Need to mark context-switches in the trace output.  */
1035   if ((CPU_CRIS_MISC_PROFILE (current_cpu)->flags
1036        & FLAG_CRIS_MISC_PROFILE_XSIM_TRACE))
1037     cris_trace_printf (CPU_STATE (current_cpu), current_cpu,
1038                        "\t#:%d\n", next);
1039
1040   /* Copy the current context (if there is one) to its slot.  */
1041   if (current_cpu->thread_data[current_cpu->threadno].cpu_context)
1042     memcpy (current_cpu->thread_data[current_cpu->threadno].cpu_context,
1043             &current_cpu->cpu_data_placeholder,
1044             current_cpu->thread_cpu_data_size);
1045
1046   /* Copy the new context from its slot.  */
1047   memcpy (&current_cpu->cpu_data_placeholder,
1048           current_cpu->thread_data[next].cpu_context,
1049           current_cpu->thread_cpu_data_size);
1050
1051   /* Update needed stuff to indicate the new context.  */
1052   current_cpu->threadno = next;
1053
1054   /* Handle pending signals.  */
1055   if (current_cpu->thread_data[next].sigpending
1056       /* We don't run nested signal handlers.  This means that pause(2)
1057          and sigsuspend(2) do not work in sighandlers, but that
1058          shouldn't be too hard a restriction.  It also greatly
1059          simplifies the code.  */
1060       && current_cpu->thread_data[next].cpu_context_atsignal == NULL)
1061   {
1062     int sig;
1063
1064     /* See if there's really a pending, non-blocked handler.  We don't
1065        queue signals, so just use the first one in ascending order.  */
1066     for (sig = 0; sig < 64; sig++)
1067       if (current_cpu->thread_data[next].sigdata[sig].pending
1068           && !current_cpu->thread_data[next].sigdata[sig].blocked)
1069       {
1070         bfd_byte regbuf[4];
1071         USI sp;
1072         int i;
1073         USI blocked;
1074         USI pc = sim_pc_get (current_cpu);
1075
1076         /* It's simpler to save the CPU context inside the simulator
1077            than on the stack.  */
1078         current_cpu->thread_data[next].cpu_context_atsignal
1079           = (*current_cpu
1080              ->make_thread_cpu_data) (current_cpu,
1081                                       current_cpu->thread_data[next]
1082                                       .cpu_context);
1083
1084         (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_SP, regbuf, 4);
1085         sp = bfd_getl32 (regbuf);
1086
1087         /* Make sure we have an aligned stack.  */
1088         sp &= ~3;
1089
1090         /* Make room for the signal frame, aligned.  FIXME: Check that
1091            the memory exists, map it in if absent.  (BTW, should also
1092            implement on-access automatic stack allocation).  */
1093         sp -= 20;
1094
1095         /* This isn't the same signal frame as the kernel uses, because
1096            we don't want to bother getting all registers on and off the
1097            stack.  */
1098
1099         /* First, we store the currently blocked signals.  */
1100         blocked = 0;
1101         for (i = 0; i < 32; i++)
1102           blocked
1103             |= current_cpu->thread_data[next].sigdata[i + 1].blocked << i;
1104         sim_core_write_aligned_4 (current_cpu, pc, 0, sp, blocked);
1105         blocked = 0;
1106         for (i = 0; i < 31; i++)
1107           blocked
1108             |= current_cpu->thread_data[next].sigdata[i + 33].blocked << i;
1109         sim_core_write_aligned_4 (current_cpu, pc, 0, sp + 4, blocked);
1110
1111         /* Then, the actual instructions.  This is CPU-specific, but we
1112            use instructions from the common subset for v10 and v32 which
1113            should be safe for the time being but could be parametrized
1114            if need be.  */
1115         /* MOVU.W [PC+],R9.  */
1116         sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 8, 0x9c5f);
1117         /* .WORD TARGET_SYS_sigreturn.  */
1118         sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 10,
1119                                   TARGET_SYS_sigreturn);
1120         /* BREAK 13.  */
1121         sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 12, 0xe93d);
1122
1123         /* NOP (on v32; it's SETF on v10, but is the correct compatible
1124            instruction.  Still, it doesn't matter because v10 has no
1125            delay slot for BREAK so it will not be executed).  */
1126         sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 16, 0x05b0);
1127
1128         /* Modify registers to hold the right values for the sighandler
1129            context: updated stackpointer and return address pointing to
1130            the sigreturn stub.  */
1131         bfd_putl32 (sp, regbuf);
1132         (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_SP, regbuf, 4);
1133         bfd_putl32 (sp + 8, regbuf);
1134         (*CPU_REG_STORE (current_cpu)) (current_cpu, TARGET_SRP_REGNUM,
1135                                         regbuf, 4);
1136
1137         current_cpu->thread_data[next].sigdata[sig].pending = 0;
1138
1139         /* Block this signal (for the duration of the sighandler).  */
1140         current_cpu->thread_data[next].sigdata[sig].blocked = 1;
1141
1142         sim_pc_set (current_cpu, current_cpu->sighandler[sig]);
1143         bfd_putl32 (sig, regbuf);
1144         (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R10,
1145                                         regbuf, 4);
1146
1147         /* We ignore a SA_SIGINFO flag in the sigaction call; the code I
1148            needed all this for, specifies a SA_SIGINFO call but treats it
1149            like an ordinary sighandler; only the signal number argument is
1150            inspected.  To make future need to implement SA_SIGINFO
1151            correctly possible, we set the siginfo argument register to a
1152            magic (hopefully non-address) number.  (NB: then, you should
1153            just need to pass the siginfo argument; it seems you probably
1154            don't need to implement the specific rt_sigreturn.)  */
1155         bfd_putl32 (0xbad5161f, regbuf);
1156         (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R11,
1157                                         regbuf, 4);
1158
1159         /* The third argument is unused and the kernel sets it to 0.  */
1160         bfd_putl32 (0, regbuf);
1161         (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R12,
1162                                         regbuf, 4);
1163         return;
1164       }
1165
1166     /* No, there actually was no pending signal for this thread.  Reset
1167        this flag.  */
1168     current_cpu->thread_data[next].sigpending = 0;
1169   }
1170 }
1171
1172 /* Reschedule the simplest possible way until something else is absolutely
1173    necessary:
1174    - A. Find the next process (round-robin) that doesn't have at_syscall
1175         set, schedule it.
1176    - B. If there is none, just run the next process, round-robin.
1177    - Clear at_syscall for the current process.  */
1178
1179 static void
1180 reschedule (SIM_CPU *current_cpu)
1181 {
1182   int i;
1183
1184   /* Iterate over all thread slots, because after a few thread creations
1185      and exits, we don't know where the live ones are.  */
1186   for (i = (current_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
1187        i != current_cpu->threadno;
1188        i = (i + 1) % SIM_TARGET_MAX_THREADS)
1189     if (current_cpu->thread_data[i].cpu_context
1190         && current_cpu->thread_data[i].at_syscall == 0)
1191       {
1192         schedule (current_cpu, i);
1193         return;
1194       }
1195
1196   /* Pick any next live thread.  */
1197   for (i = (current_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
1198        i != current_cpu->threadno;
1199        i = (i + 1) % SIM_TARGET_MAX_THREADS)
1200     if (current_cpu->thread_data[i].cpu_context)
1201       {
1202         schedule (current_cpu, i);
1203         return;
1204       }
1205
1206   /* More than one live thread, but we couldn't find the next one?  */
1207   abort ();
1208 }
1209
1210 /* Set up everything to receive (or IGN) an incoming signal to the
1211    current context.  */
1212
1213 static int
1214 deliver_signal (SIM_CPU *current_cpu, int sig, unsigned int pid)
1215 {
1216   int i;
1217   USI pc = sim_pc_get (current_cpu);
1218
1219   /* Find the thread index of the pid. */
1220   for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
1221     /* Apparently it's ok to send signals to zombies (so a check for
1222        current_cpu->thread_data[i].cpu_context != NULL would be
1223        wrong). */
1224     if (current_cpu->thread_data[i].threadid == pid - TARGET_PID)
1225       {
1226         if (sig < 64)
1227           switch (current_cpu->sighandler[sig])
1228             {
1229             case TARGET_SIG_DFL:
1230               switch (sig)
1231                 {
1232                   /* The following according to the glibc
1233                      documentation. (The kernel code has non-obvious
1234                      execution paths.)  */
1235                 case TARGET_SIGFPE:
1236                 case TARGET_SIGILL:
1237                 case TARGET_SIGSEGV:
1238                 case TARGET_SIGBUS:
1239                 case TARGET_SIGABRT:
1240                 case TARGET_SIGTRAP:
1241                 case TARGET_SIGSYS:
1242
1243                 case TARGET_SIGTERM:
1244                 case TARGET_SIGINT:
1245                 case TARGET_SIGQUIT:
1246                 case TARGET_SIGKILL:
1247                 case TARGET_SIGHUP:
1248
1249                 case TARGET_SIGALRM:
1250                 case TARGET_SIGVTALRM:
1251                 case TARGET_SIGPROF:
1252                 case TARGET_SIGSTOP:
1253
1254                 case TARGET_SIGPIPE:
1255                 case TARGET_SIGLOST:
1256                 case TARGET_SIGXCPU:
1257                 case TARGET_SIGXFSZ:
1258                 case TARGET_SIGUSR1:
1259                 case TARGET_SIGUSR2:
1260                   sim_io_eprintf (CPU_STATE (current_cpu),
1261                                   "Exiting pid %d due to signal %d\n",
1262                                   pid, sig);
1263                   sim_engine_halt (CPU_STATE (current_cpu), current_cpu,
1264                                    NULL, pc, sim_stopped,
1265                                    sig == TARGET_SIGABRT
1266                                    ? SIM_SIGABRT : SIM_SIGILL);
1267                   return 0;
1268
1269                   /* The default for all other signals is to be ignored.  */
1270                 default:
1271                   return 0;
1272                 }
1273
1274             case TARGET_SIG_IGN:
1275               switch (sig)
1276                 {
1277                 case TARGET_SIGKILL:
1278                 case TARGET_SIGSTOP:
1279                   /* Can't ignore these signals.  */
1280                   sim_io_eprintf (CPU_STATE (current_cpu),
1281                                   "Exiting pid %d due to signal %d\n",
1282                                   pid, sig);
1283                   sim_engine_halt (CPU_STATE (current_cpu), current_cpu,
1284                                    NULL, pc, sim_stopped, SIM_SIGILL);
1285                   return 0;
1286
1287                 default:
1288                   return 0;
1289                 }
1290               break;
1291
1292             default:
1293               /* Mark the signal as pending, making schedule () check
1294                  closer.  The signal will be handled when the thread is
1295                  scheduled and the signal is unblocked.  */
1296               current_cpu->thread_data[i].sigdata[sig].pending = 1;
1297               current_cpu->thread_data[i].sigpending = 1;
1298               return 0;
1299             }
1300         else
1301           {
1302             sim_io_eprintf (CPU_STATE (current_cpu),
1303                             "Unimplemented signal: %d\n", sig);
1304             sim_engine_halt (CPU_STATE (current_cpu), current_cpu, NULL, pc,
1305                              sim_stopped, SIM_SIGILL);
1306           }
1307       }
1308
1309   return
1310     -cb_host_to_target_errno (STATE_CALLBACK (CPU_STATE (current_cpu)),
1311                               ESRCH);
1312 }
1313
1314 /* Make the vector and the first item, the main thread.  */
1315
1316 static void
1317 make_first_thread (SIM_CPU *current_cpu)
1318 {
1319   current_cpu->thread_data
1320     = xcalloc (1,
1321                SIM_TARGET_MAX_THREADS
1322                * sizeof (current_cpu->thread_data[0]));
1323   current_cpu->thread_data[0].cpu_context
1324     = (*current_cpu->make_thread_cpu_data) (current_cpu,
1325                                             &current_cpu
1326                                             ->cpu_data_placeholder);
1327   current_cpu->thread_data[0].parent_threadid = -1;
1328
1329   /* For good measure.  */
1330   if (TARGET_SIG_DFL != 0)
1331     abort ();
1332 }
1333
1334 /* Main function: the handler of the "break 13" syscall insn.  */
1335
1336 USI
1337 cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
1338                        USI arg2, USI arg3, USI arg4, USI arg5, USI arg6,
1339                        USI pc)
1340 {
1341   CB_SYSCALL s;
1342   SIM_DESC sd = CPU_STATE (current_cpu);
1343   host_callback *cb = STATE_CALLBACK (sd);
1344   int retval;
1345   int threadno = current_cpu->threadno;
1346
1347   current_cpu->syscalls++;
1348
1349   CB_SYSCALL_INIT (&s);
1350   s.func = callnum;
1351   s.arg1 = arg1;
1352   s.arg2 = arg2;
1353   s.arg3 = arg3;
1354
1355   if (callnum == TARGET_SYS_exit && current_cpu->m1threads == 0)
1356     {
1357       if (CPU_CRIS_MISC_PROFILE (current_cpu)->flags
1358           & FLAG_CRIS_MISC_PROFILE_ALL)
1359         dump_statistics (current_cpu);
1360       sim_engine_halt (sd, current_cpu, NULL, pc, sim_exited, arg1);
1361     }
1362
1363   s.p1 = (PTR) sd;
1364   s.p2 = (PTR) current_cpu;
1365   s.read_mem = syscall_read_mem;
1366   s.write_mem = syscall_write_mem;
1367
1368   current_cpu_for_cb_callback = current_cpu;
1369
1370   if (cb_syscall (cb, &s) != CB_RC_OK)
1371     {
1372       abort ();
1373       sim_io_eprintf (sd, "Break 13: invalid %d?  Returned %ld\n", callnum,
1374                       s.result);
1375       sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGILL);
1376     }
1377
1378   retval = s.result == -1 ? -s.errcode : s.result;
1379
1380   if (s.errcode != 0 && s.errcode == cb_host_to_target_errno (cb, ENOSYS))
1381     {
1382       /* If the generic simulator call said ENOSYS, then let's try the
1383          ones we know ourselves.
1384
1385          The convention is to provide *very limited* functionality on an
1386          as-needed basis, only what's covered by the test-suite, tests
1387          added when functionality changes and abort with a descriptive
1388          message for *everything* else.  Where there's no test-case, we
1389          just abort.  */
1390       switch (callnum)
1391         {
1392         case 0:
1393           /* It's a pretty safe bet that the "old setup() system call"
1394              number will not be re-used; we can't say the same for higher
1395              numbers.  We treat this simulator-generated call as "wait
1396              forever"; we re-run this insn.  The wait is ended by a
1397              callback.  Sanity check that this is the reason we got
1398              here. */
1399           if (current_cpu->thread_data == NULL
1400               || (current_cpu->thread_data[threadno].pipe_write_fd == 0))
1401             goto unimplemented_syscall;
1402
1403           sim_pc_set (current_cpu, pc);
1404           retval = arg1;
1405           break;
1406
1407         case TARGET_SYS_fcntl64:
1408         case TARGET_SYS_fcntl:
1409           switch (arg2)
1410             {
1411             case 1:
1412               /* F_GETFD.
1413                  Glibc checks stdin, stdout and stderr fd:s for
1414                  close-on-exec security sanity.  We just need to provide a
1415                  OK return value.  If we really need to have a
1416                  close-on-exec flag true, we could just do a real fcntl
1417                  here.  */
1418               retval = 0;
1419               break;
1420
1421             case 2:
1422               /* F_SETFD.  Just ignore attempts to set the close-on-exec
1423                  flag.  */
1424               retval = 0;
1425               break;
1426
1427             case 3:
1428               /* F_GETFL.  Check for the special case for open+fdopen.  */
1429               if (current_cpu->last_syscall == TARGET_SYS_open
1430                   && arg1 == current_cpu->last_open_fd)
1431                 {
1432                   retval = current_cpu->last_open_flags & TARGET_O_ACCMODE;
1433                   break;
1434                 }
1435               else if (arg1 == 0)
1436                 {
1437                   /* Because we can't freopen fd:s 0, 1, 2 to mean
1438                      something else than stdin, stdout and stderr
1439                      (sim/common/syscall.c:cb_syscall special cases fd
1440                      0, 1 and 2), we know what flags that we can
1441                      sanely return for these fd:s.  */
1442                   retval = TARGET_O_RDONLY;
1443                   break;
1444                 }
1445               else if (arg1 == 1 || arg1 == 2)
1446                 {
1447                   retval = TARGET_O_WRONLY;
1448                   break;
1449                 }
1450               /* FALLTHROUGH */
1451             default:
1452               /* Abort for all other cases.  */
1453               sim_io_eprintf (sd, "Unimplemented %s syscall "
1454                               "(fd: 0x%lx: cmd: 0x%lx arg: 0x%lx)\n",
1455                               callnum == TARGET_SYS_fcntl
1456                               ? "fcntl" : "fcntl64",
1457                               (unsigned long) (USI) arg1,
1458                               (unsigned long) (USI) arg2,
1459                               (unsigned long) (USI) arg3);
1460               sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
1461                                SIM_SIGILL);
1462               break;
1463             }
1464           break;
1465
1466         case TARGET_SYS_uname:
1467           {
1468             /* Fill in a few constants to appease glibc.  */
1469             static const char sim_utsname[6][65] =
1470             {
1471               "Linux",
1472               "sim-target",
1473               "2.4.5",
1474               TARGET_UTSNAME,
1475               "cris",
1476               "localdomain"
1477             };
1478
1479             if ((s.write_mem) (cb, &s, arg1, (const char *) sim_utsname,
1480                                sizeof (sim_utsname))
1481                 != sizeof (sim_utsname))
1482               retval = -cb_host_to_target_errno (cb, EFAULT);
1483             else
1484               retval = 0;
1485             break;
1486           }
1487
1488         case TARGET_SYS_geteuid32:
1489           /* We tell the truth with these.  Maybe we shouldn't, but it
1490              should match the "stat" information.  */
1491           retval = geteuid ();
1492           break;
1493
1494         case TARGET_SYS_getuid32:
1495           retval = getuid ();
1496           break;
1497
1498         case TARGET_SYS_getegid32:
1499           retval = getegid ();
1500           break;
1501
1502         case TARGET_SYS_getgid32:
1503           retval = getgid ();
1504           break;
1505
1506         case TARGET_SYS_brk:
1507           /* Most often, we just return the argument, like the Linux
1508              kernel.  */
1509           retval = arg1;
1510
1511           if (arg1 == 0)
1512             retval = current_cpu->endbrk;
1513           else if (arg1 <= current_cpu->endmem)
1514             current_cpu->endbrk = arg1;
1515           else
1516             {
1517               USI new_end = (arg1 + 8191) & ~8191;
1518
1519               /* If the simulator wants to brk more than a certain very
1520                  large amount, something is wrong.  FIXME: Return an error
1521                  or abort?  Have command-line selectable?  */
1522               if (new_end - current_cpu->endmem > SIM_MAX_ALLOC_CHUNK)
1523                 {
1524                   current_cpu->endbrk = current_cpu->endmem;
1525                   retval = current_cpu->endmem;
1526                   break;
1527                 }
1528
1529               sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
1530                                current_cpu->endmem,
1531                                new_end - current_cpu->endmem,
1532                                0, NULL, NULL);
1533               current_cpu->endbrk = arg1;
1534               current_cpu->endmem = new_end;
1535             }
1536           break;
1537
1538         case TARGET_SYS_getpid:
1539           /* Correct until CLONE_THREAD is implemented.  */
1540           retval = current_cpu->thread_data == NULL
1541             ? TARGET_PID
1542             : TARGET_PID + current_cpu->thread_data[threadno].threadid;
1543           break;
1544
1545         case TARGET_SYS_getppid:
1546           /* Correct until CLONE_THREAD is implemented.  */
1547           retval = current_cpu->thread_data == NULL
1548             ? TARGET_PID - 1
1549             : (TARGET_PID
1550                + current_cpu->thread_data[threadno].parent_threadid);
1551           break;
1552
1553         case TARGET_SYS_mmap2:
1554           {
1555             USI addr = arg1;
1556             USI len = arg2;
1557             USI prot = arg3;
1558             USI flags = arg4;
1559             USI fd = arg5;
1560             USI pgoff = arg6;
1561
1562             /* If the simulator wants to mmap more than the very large
1563                limit, something is wrong.  FIXME: Return an error or
1564                abort?  Have command-line selectable?  */
1565             if (len > SIM_MAX_ALLOC_CHUNK)
1566               {
1567                 retval = -cb_host_to_target_errno (cb, ENOMEM);
1568                 break;
1569               }
1570
1571             if ((prot != (TARGET_PROT_READ | TARGET_PROT_WRITE)
1572                  && (prot
1573                      != (TARGET_PROT_READ
1574                          | TARGET_PROT_WRITE
1575                          | TARGET_PROT_EXEC))
1576                  && prot != TARGET_PROT_READ)
1577                 || (flags != (TARGET_MAP_ANONYMOUS | TARGET_MAP_PRIVATE)
1578                     && flags != TARGET_MAP_PRIVATE
1579                     && flags != TARGET_MAP_SHARED)
1580                 || (fd != (USI) -1 && prot != TARGET_PROT_READ)
1581                 || pgoff != 0)
1582               {
1583                 sim_io_eprintf (sd, "Unimplemented mmap2 call "
1584                                 "(0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
1585                                 (unsigned long) arg1,
1586                                 (unsigned long) arg2,
1587                                 (unsigned long) arg3,
1588                                 (unsigned long) arg4,
1589                                 (unsigned long) arg5,
1590                                 (unsigned long) arg6);
1591                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
1592                                  SIM_SIGILL);
1593                 break;
1594               }
1595             else if (fd != (USI) -1)
1596               {
1597                 /* Map a file.  */
1598
1599                 USI newaddr;
1600                 USI pos;
1601
1602                 /* A non-aligned argument is allowed for files.  */
1603                 USI newlen = (len + 8191) & ~8191;
1604
1605                 /* We only support read, which we should already have
1606                    checked.  Check again anyway.  */
1607                 if (prot != TARGET_PROT_READ)
1608                   abort ();
1609
1610                 newaddr
1611                   = create_map (sd, &current_cpu->highest_mmapped_page, addr,
1612                                 newlen);
1613
1614                 if (newaddr >= (USI) -8191)
1615                   {
1616                     abort ();
1617                     retval = -cb_host_to_target_errno (cb, -(SI) newaddr);
1618                     break;
1619                   }
1620
1621                 /* Find the current position in the file.  */
1622                 s.func = TARGET_SYS_lseek;
1623                 s.arg1 = fd;
1624                 s.arg2 = 0;
1625                 s.arg3 = SEEK_CUR;
1626                 if (cb_syscall (cb, &s) != CB_RC_OK)
1627                   abort ();
1628                 pos = s.result;
1629
1630                 if (s.result < 0)
1631                   abort ();
1632
1633                 /* Use the standard read callback to read in "len"
1634                    bytes.  */
1635                 s.func = TARGET_SYS_read;
1636                 s.arg1 = fd;
1637                 s.arg2 = newaddr;
1638                 s.arg3 = len;
1639                 if (cb_syscall (cb, &s) != CB_RC_OK)
1640                   abort ();
1641
1642                 if ((USI) s.result != len)
1643                   abort ();
1644
1645                 /* After reading, we need to go back to the previous
1646                    position in the file.  */
1647                 s.func = TARGET_SYS_lseek;
1648                 s.arg1 = fd;
1649                 s.arg2 = pos;
1650                 s.arg3 = SEEK_SET;
1651                 if (cb_syscall (cb, &s) != CB_RC_OK)
1652                   abort ();
1653                 if (pos != (USI) s.result)
1654                   abort ();
1655
1656                 retval = newaddr;
1657               }
1658             else
1659               {
1660                 USI newaddr
1661                   = create_map (sd, &current_cpu->highest_mmapped_page, addr,
1662                                 (len + 8191) & ~8191);
1663
1664                 if (newaddr >= (USI) -8191)
1665                   retval = -cb_host_to_target_errno (cb, -(SI) newaddr);
1666                 else
1667                   retval = newaddr;
1668               }
1669             break;
1670           }
1671
1672         case TARGET_SYS_mprotect:
1673           {
1674             /* We only cover the case of linuxthreads mprotecting out its
1675                stack guard page.  */
1676             USI addr = arg1;
1677             USI len = arg2;
1678             USI prot = arg3;
1679
1680             if ((addr & 8191) != 0
1681                 || len != 8192
1682                 || prot != TARGET_PROT_NONE
1683                 || !is_mapped (sd, &current_cpu->highest_mmapped_page, addr,
1684                                len))
1685               {
1686                 sim_io_eprintf (sd, "Unimplemented mprotect call "
1687                                 "(0x%lx, 0x%lx, 0x%lx)\n",
1688                                 (unsigned long) arg1,
1689                                 (unsigned long) arg2,
1690                                 (unsigned long) arg3);
1691                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
1692                                  SIM_SIGILL);
1693                 break;
1694               }
1695
1696             /* FIXME: We should account for pages like this that are
1697                "mprotected out".  For now, we just tell the simulator
1698                core to remove that page from its map.  */
1699             sim_core_detach (sd, NULL, 0, 0, addr);
1700             retval = 0;
1701             break;
1702           }
1703
1704         case TARGET_SYS_ioctl:
1705           {
1706             /* We support only a very limited functionality: checking
1707                stdout with TCGETS to perform the isatty function.  The
1708                TCGETS ioctl isn't actually performed or the result used by
1709                an isatty () caller in a "hello, world" program; only the
1710                return value is then used.  Maybe we shouldn't care about
1711                the environment of the simulator regarding isatty, but
1712                that's been working before, in the xsim simulator.  */
1713             if (arg2 == TARGET_TCGETS && arg1 == 1)
1714               retval = isatty (1) ? 0 : cb_host_to_target_errno (cb, EINVAL);
1715             else
1716               retval = -cb_host_to_target_errno (cb, EINVAL);
1717             break;
1718           }
1719
1720         case TARGET_SYS_munmap:
1721           {
1722             USI addr = arg1;
1723             USI len = arg2;
1724             USI result
1725               = unmap_pages (sd, &current_cpu->highest_mmapped_page, addr,
1726                              len);
1727             retval = result != 0 ? -cb_host_to_target_errno (cb, result) : 0;
1728             break;
1729           }
1730
1731         case TARGET_SYS_wait4:
1732           {
1733             int i;
1734             USI pid = arg1;
1735             USI saddr = arg2;
1736             USI options = arg3;
1737             USI rusagep = arg4;
1738
1739             /* FIXME: We're not properly implementing __WCLONE, and we
1740                don't really need the special casing so we might as well
1741                make this general.  */
1742             if ((!(pid == (USI) -1
1743                    && options == (TARGET___WCLONE | TARGET_WNOHANG)
1744                    && saddr != 0)
1745                  && !(pid > 0
1746                       && (options == TARGET___WCLONE
1747                           || options == TARGET___WALL)))
1748                 || rusagep != 0
1749                 || current_cpu->thread_data == NULL)
1750               {
1751                 sim_io_eprintf (sd, "Unimplemented wait4 call "
1752                                 "(0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
1753                                 (unsigned long) arg1,
1754                                 (unsigned long) arg2,
1755                                 (unsigned long) arg3,
1756                                 (unsigned long) arg4);
1757                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
1758                                  SIM_SIGILL);
1759                 break;
1760               }
1761
1762             if (pid == (USI) -1)
1763               for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
1764                 {
1765                   if (current_cpu->thread_data[threadno].threadid
1766                       == current_cpu->thread_data[i].parent_threadid
1767                       && current_cpu->thread_data[i].threadid != 0
1768                       && current_cpu->thread_data[i].cpu_context == NULL)
1769                     {
1770                       /* A zombied child.  Get the exit value and clear the
1771                          zombied entry so it will be reused.  */
1772                       sim_core_write_unaligned_4 (current_cpu, pc, 0, saddr,
1773                                                   current_cpu
1774                                                   ->thread_data[i].exitval);
1775                       retval
1776                         = current_cpu->thread_data[i].threadid + TARGET_PID;
1777                       memset (&current_cpu->thread_data[i], 0,
1778                               sizeof (current_cpu->thread_data[i]));
1779                       goto outer_break;
1780                     }
1781                 }
1782             else
1783               {
1784                 /* We're waiting for a specific PID.  If we don't find
1785                    it zombied on this run, rerun the syscall.  */
1786                 for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
1787                   if (pid == current_cpu->thread_data[i].threadid + TARGET_PID
1788                       && current_cpu->thread_data[i].cpu_context == NULL)
1789                     {
1790                       if (saddr != 0)
1791                         /* Get the exit value if the caller wants it.  */
1792                         sim_core_write_unaligned_4 (current_cpu, pc, 0,
1793                                                     saddr,
1794                                                     current_cpu
1795                                                     ->thread_data[i]
1796                                                     .exitval);
1797
1798                       retval
1799                         = current_cpu->thread_data[i].threadid + TARGET_PID;
1800                       memset (&current_cpu->thread_data[i], 0,
1801                               sizeof (current_cpu->thread_data[i]));
1802
1803                       goto outer_break;
1804                     }
1805
1806                 sim_pc_set (current_cpu, pc);
1807               }
1808
1809             retval = -cb_host_to_target_errno (cb, ECHILD);
1810           outer_break:
1811             break;
1812           }
1813
1814         case TARGET_SYS_rt_sigaction:
1815           {
1816             USI signum = arg1;
1817             USI old_sa = arg3;
1818             USI new_sa = arg2;
1819
1820             /* The kernel says:
1821                struct sigaction {
1822                         __sighandler_t sa_handler;
1823                         unsigned long sa_flags;
1824                         void (*sa_restorer)(void);
1825                         sigset_t sa_mask;
1826                }; */
1827
1828             if (old_sa != 0)
1829               {
1830                 sim_core_write_unaligned_4 (current_cpu, pc, 0, old_sa + 0,
1831                                             current_cpu->sighandler[signum]);
1832                 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 4, 0);
1833                 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 8, 0);
1834
1835                 /* We'll assume _NSIG_WORDS is 2 for the kernel.  */
1836                 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 12, 0);
1837                 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 16, 0);
1838               }
1839             if (new_sa != 0)
1840               {
1841                 USI target_sa_handler
1842                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa);
1843                 USI target_sa_flags
1844                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 4);
1845                 USI target_sa_restorer
1846                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 8);
1847                 USI target_sa_mask_low
1848                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 12);
1849                 USI target_sa_mask_high
1850                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 16);
1851
1852                 /* We won't interrupt a syscall so we won't restart it,
1853                    but a signal(2) call ends up syscalling rt_sigaction
1854                    with this flag, so we have to handle it.  The
1855                    sa_restorer field contains garbage when not
1856                    TARGET_SA_RESTORER, so don't look at it.  For the
1857                    time being, we don't nest sighandlers, so we
1858                    ignore the sa_mask, which simplifies things.  */
1859                 if ((target_sa_flags != 0
1860                      && target_sa_flags != TARGET_SA_RESTART
1861                      && target_sa_flags != (TARGET_SA_RESTART|TARGET_SA_SIGINFO))
1862                     || target_sa_handler == 0)
1863                   {
1864                     sim_io_eprintf (sd, "Unimplemented rt_sigaction "
1865                                     "syscall (0x%lx, "
1866                                     "0x%lx: [0x%x, 0x%x, 0x%x, "
1867                                     "{0x%x, 0x%x}], "
1868                                     "0x%lx)\n",
1869                                     (unsigned long) arg1,
1870                                     (unsigned long) arg2,
1871                                     target_sa_handler, target_sa_flags,
1872                                     target_sa_restorer,
1873                                     target_sa_mask_low, target_sa_mask_high,
1874                                     (unsigned long) arg3);
1875                     sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
1876                                      SIM_SIGILL);
1877                   }
1878
1879                 current_cpu->sighandler[signum] = target_sa_handler;
1880
1881                 /* Because we may have unblocked signals, one may now be
1882                    pending, if there are threads, that is.  */
1883                 if (current_cpu->thread_data)
1884                   current_cpu->thread_data[threadno].sigpending = 1;
1885               }
1886             retval = 0;
1887             break;
1888           }
1889
1890         case TARGET_SYS_mremap:
1891           {
1892             USI addr = arg1;
1893             USI old_len = arg2;
1894             USI new_len = arg3;
1895             USI flags = arg4;
1896             USI new_addr = arg5;
1897             USI mapped_addr;
1898
1899             if (new_len == old_len)
1900               /* The program and/or library is possibly confused but
1901                  this is a valid call.  Happens with ipps-1.40 on file
1902                  svs_all.  */
1903               retval = addr;
1904             else if (new_len < old_len)
1905               {
1906                 /* Shrinking is easy.  */
1907                 if (unmap_pages (sd, &current_cpu->highest_mmapped_page,
1908                                  addr + new_len, old_len - new_len) != 0)
1909                   retval = -cb_host_to_target_errno (cb, EINVAL);
1910                 else
1911                   retval = addr;
1912               }
1913             else if (! is_mapped (sd, &current_cpu->highest_mmapped_page,
1914                                   addr + old_len, new_len - old_len))
1915               {
1916                 /* If the extension isn't mapped, we can just add it.  */
1917                 mapped_addr
1918                   = create_map (sd, &current_cpu->highest_mmapped_page,
1919                                 addr + old_len, new_len - old_len);
1920
1921                 if (mapped_addr > (USI) -8192)
1922                   retval = -cb_host_to_target_errno (cb, -(SI) mapped_addr);
1923                 else
1924                   retval = addr;
1925               }
1926             else if (flags & TARGET_MREMAP_MAYMOVE)
1927               {
1928                 /* Create a whole new map and copy the contents
1929                    block-by-block there.  We ignore the new_addr argument
1930                    for now.  */
1931                 char buf[8192];
1932                 USI prev_addr = addr;
1933                 USI prev_len = old_len;
1934
1935                 mapped_addr
1936                   = create_map (sd, &current_cpu->highest_mmapped_page,
1937                                 0, new_len);
1938
1939                 if (mapped_addr > (USI) -8192)
1940                   {
1941                     retval = -cb_host_to_target_errno (cb, -(SI) new_addr);
1942                     break;
1943                   }
1944
1945                 retval = mapped_addr;
1946
1947                 for (; old_len > 0;
1948                      old_len -= 8192, mapped_addr += 8192, addr += 8192)
1949                   {
1950                     if (sim_core_read_buffer (sd, current_cpu, read_map, buf,
1951                                               addr, 8192) != 8192
1952                         || sim_core_write_buffer (sd, current_cpu, 0, buf,
1953                                                   mapped_addr, 8192) != 8192)
1954                       abort ();
1955                   }
1956
1957                 if (unmap_pages (sd, &current_cpu->highest_mmapped_page,
1958                                  prev_addr, prev_len) != 0)
1959                   abort ();
1960               }
1961             else
1962               retval = -cb_host_to_target_errno (cb, -ENOMEM);
1963             break;
1964           }
1965
1966         case TARGET_SYS_poll:
1967           {
1968             int npollfds = arg2;
1969             int timeout = arg3;
1970             SI ufds = arg1;
1971             SI fd = -1;
1972             HI events = -1;
1973             HI revents = 0;
1974             struct stat buf;
1975             int i;
1976
1977             /* The kernel says:
1978                 struct pollfd {
1979                      int fd;
1980                      short events;
1981                      short revents;
1982                 }; */
1983
1984             /* Check that this is the expected poll call from
1985                linuxthreads/manager.c; we don't support anything else.
1986                Remember, fd == 0 isn't supported.  */
1987             if (npollfds != 1
1988                 || ((fd = sim_core_read_unaligned_4 (current_cpu, pc,
1989                                                      0, ufds)) <= 0)
1990                 || ((events = sim_core_read_unaligned_2 (current_cpu, pc,
1991                                                          0, ufds + 4))
1992                     != TARGET_POLLIN)
1993                 || ((cb->fstat) (cb, fd, &buf) != 0
1994                     || (buf.st_mode & S_IFIFO) == 0)
1995                 || current_cpu->thread_data == NULL)
1996               {
1997                 sim_io_eprintf (sd, "Unimplemented poll syscall "
1998                                 "(0x%lx: [0x%x, 0x%x, x], 0x%lx, 0x%lx)\n",
1999                                 (unsigned long) arg1, fd, events,
2000                                 (unsigned long) arg2, (unsigned long) arg3);
2001                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGILL);
2002                 break;
2003               }
2004
2005             retval = 0;
2006
2007             /* Iterate over threads; find a marker that a writer is
2008                sleeping, waiting for a reader.  */
2009             for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
2010               if (current_cpu->thread_data[i].cpu_context != NULL
2011                   && current_cpu->thread_data[i].pipe_read_fd == fd)
2012                 {
2013                   revents = TARGET_POLLIN;
2014                   retval = 1;
2015                   break;
2016                 }
2017
2018             /* Timeout decreases with whatever time passed between the
2019                last syscall and this.  That's not exactly right for the
2020                first call, but it's close enough that it isn't
2021                worthwhile to complicate matters by making that a special
2022                case.  */
2023             timeout
2024               -= (TARGET_TIME_MS (current_cpu)
2025                   - (current_cpu->thread_data[threadno].last_execution));
2026
2027             /* Arrange to repeat this syscall until timeout or event,
2028                decreasing timeout at each iteration.  */
2029             if (timeout > 0 && revents == 0)
2030               {
2031                 bfd_byte timeout_buf[4];
2032
2033                 bfd_putl32 (timeout, timeout_buf);
2034                 (*CPU_REG_STORE (current_cpu)) (current_cpu,
2035                                                 H_GR_R12, timeout_buf, 4);
2036                 sim_pc_set (current_cpu, pc);
2037                 retval = arg1;
2038                 break;
2039               }
2040
2041             sim_core_write_unaligned_2 (current_cpu, pc, 0, ufds + 4 + 2,
2042                                         revents);
2043             break;
2044           }
2045
2046         case TARGET_SYS_time:
2047           {
2048             retval = (int) (*cb->time) (cb, 0L);
2049
2050             /* At time of this writing, CB_SYSCALL_time doesn't do the
2051                part of setting *arg1 to the return value.  */
2052             if (arg1)
2053               sim_core_write_unaligned_4 (current_cpu, pc, 0, arg1, retval);
2054             break;
2055           }
2056
2057         case TARGET_SYS_gettimeofday:
2058           if (arg1 != 0)
2059             {
2060               USI ts = TARGET_TIME (current_cpu);
2061               USI tms = TARGET_TIME_MS (current_cpu);
2062
2063               /* First dword is seconds since TARGET_EPOCH.  */
2064               sim_core_write_unaligned_4 (current_cpu, pc, 0, arg1, ts);
2065
2066               /* Second dword is microseconds.  */
2067               sim_core_write_unaligned_4 (current_cpu, pc, 0, arg1 + 4,
2068                                           (tms % 1000) * 1000);
2069             }
2070           if (arg2 != 0)
2071             {
2072               /* Time-zone info is always cleared.  */
2073               sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2, 0);
2074               sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2 + 4, 0);
2075             }
2076           retval = 0;
2077           break;
2078
2079         case TARGET_SYS_llseek:
2080           {
2081             /* If it fits, tweak parameters to fit the "generic" 32-bit
2082                lseek and use that.  */
2083             SI fd = arg1;
2084             SI offs_hi = arg2;
2085             SI offs_lo = arg3;
2086             SI resultp = arg4;
2087             SI whence = arg5;
2088             retval = 0;
2089
2090             if (!((offs_hi == 0 && offs_lo >= 0)
2091                   || (offs_hi == -1 &&  offs_lo < 0)))
2092               {
2093                 sim_io_eprintf (sd,
2094                                 "Unimplemented llseek offset,"
2095                                 " fd %d: 0x%x:0x%x\n",
2096                                 fd, (unsigned) arg2, (unsigned) arg3);
2097                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2098                                  SIM_SIGILL);
2099               }
2100
2101             s.func = TARGET_SYS_lseek;
2102             s.arg2 = offs_lo;
2103             s.arg3 = whence;
2104             if (cb_syscall (cb, &s) != CB_RC_OK)
2105               {
2106                 sim_io_eprintf (sd, "Break 13: invalid %d?  Returned %ld\n", callnum,
2107                                 s.result);
2108                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGILL);
2109               }
2110             if (s.result < 0)
2111               retval = -s.errcode;
2112             else
2113               {
2114                 sim_core_write_unaligned_4 (current_cpu, pc, 0, resultp,
2115                                             s.result);
2116                 sim_core_write_unaligned_4 (current_cpu, pc, 0, resultp + 4,
2117                                             s.result < 0 ? -1 : 0);
2118               }
2119             break;
2120           }
2121
2122         /* This one does have a generic callback function, but at the time
2123            of this writing, cb_syscall does not have code for it, and we
2124            need target-specific code for the threads implementation
2125            anyway.  */
2126         case TARGET_SYS_kill:
2127           {
2128             USI pid = arg1;
2129             USI sig = arg2;
2130
2131             retval = 0;
2132
2133             /* At kill(2), glibc sets signal masks such that the thread
2134                machinery is initialized.  Still, there is and was only
2135                one thread.  */
2136             if (current_cpu->max_threadid == 0)
2137               {
2138                 if (pid != TARGET_PID)
2139                   {
2140                     retval = -cb_host_to_target_errno (cb, EPERM);
2141                     break;
2142                   }
2143
2144                 /* FIXME: Signal infrastructure (target-to-sim mapping).  */
2145                 if (sig == TARGET_SIGABRT)
2146                   /* A call "abort ()", i.e. "kill (getpid(), SIGABRT)" is
2147                      the end-point for failing GCC test-cases.  */
2148                   sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2149                                    SIM_SIGABRT);
2150                 else
2151                   {
2152                     sim_io_eprintf (sd, "Unimplemented signal: %d\n", sig);
2153                     sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2154                                      SIM_SIGILL);
2155                   }
2156
2157                 /* This will not be reached.  */
2158                 abort ();
2159               }
2160             else
2161               retval = deliver_signal (current_cpu, sig, pid);
2162             break;
2163           }
2164
2165         case TARGET_SYS_rt_sigprocmask:
2166           {
2167             int i;
2168             USI how = arg1;
2169             USI newsetp = arg2;
2170             USI oldsetp = arg3;
2171
2172             if (how != TARGET_SIG_BLOCK
2173                 && how != TARGET_SIG_SETMASK
2174                 && how != TARGET_SIG_UNBLOCK)
2175               {
2176                 sim_io_eprintf (sd, "Unimplemented rt_sigprocmask syscall "
2177                                "(0x%x, 0x%x, 0x%x)\n", arg1, arg2, arg3);
2178                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2179                                  SIM_SIGILL);
2180                 retval = 0;
2181                 break;
2182               }
2183
2184             if (newsetp)
2185               {
2186                 USI set_low
2187                   = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2188                                                newsetp);
2189                 USI set_high
2190                   = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2191                                                newsetp + 4);
2192
2193                 /* The sigmask is kept in the per-thread data, so we may
2194                    need to create the first one.  */
2195                 if (current_cpu->thread_data == NULL)
2196                   make_first_thread (current_cpu);
2197
2198                 if (how == TARGET_SIG_SETMASK)
2199                   for (i = 0; i < 64; i++)
2200                     current_cpu->thread_data[threadno].sigdata[i].blocked = 0;
2201
2202                 for (i = 0; i < 32; i++)
2203                   if ((set_low & (1 << i)))
2204                     current_cpu->thread_data[threadno].sigdata[i + 1].blocked
2205                       = (how != TARGET_SIG_UNBLOCK);
2206
2207                 for (i = 0; i < 31; i++)
2208                   if ((set_high & (1 << i)))
2209                     current_cpu->thread_data[threadno].sigdata[i + 33].blocked
2210                       = (how != TARGET_SIG_UNBLOCK);
2211
2212                 /* The mask changed, so a signal may be unblocked for
2213                    execution.  */
2214                 current_cpu->thread_data[threadno].sigpending = 1;
2215               }
2216
2217             if (oldsetp != 0)
2218               {
2219                 USI set_low = 0;
2220                 USI set_high = 0;
2221
2222                 for (i = 0; i < 32; i++)
2223                   if (current_cpu->thread_data[threadno]
2224                       .sigdata[i + 1].blocked)
2225                     set_low |= 1 << i;
2226                 for (i = 0; i < 31; i++)
2227                   if (current_cpu->thread_data[threadno]
2228                       .sigdata[i + 33].blocked)
2229                     set_high |= 1 << i;
2230
2231                 sim_core_write_unaligned_4 (current_cpu, pc, 0, oldsetp + 0, set_low);
2232                 sim_core_write_unaligned_4 (current_cpu, pc, 0, oldsetp + 4, set_high);
2233               }
2234
2235             retval = 0;
2236             break;
2237           }
2238
2239         case TARGET_SYS_sigreturn:
2240           {
2241             int i;
2242             bfd_byte regbuf[4];
2243             int was_sigsuspended;
2244
2245             if (current_cpu->thread_data == NULL
2246                 /* The CPU context is saved with the simulator data, not
2247                    on the stack as in the real world.  */
2248                 || (current_cpu->thread_data[threadno].cpu_context_atsignal
2249                     == NULL))
2250               {
2251                 sim_io_eprintf (sd, "Invalid sigreturn syscall: no signal"
2252                                 " handler active "
2253                                 "(0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
2254                                 (unsigned long) arg1,
2255                                 (unsigned long) arg2,
2256                                 (unsigned long) arg3,
2257                                 (unsigned long) arg4,
2258                                 (unsigned long) arg5,
2259                                 (unsigned long) arg6);
2260                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2261                                  SIM_SIGILL);
2262               }
2263
2264             was_sigsuspended
2265               = current_cpu->thread_data[threadno].sigsuspended;
2266
2267             /* Restore the sigmask, either from the stack copy made when
2268                the sighandler was called, or from the saved state
2269                specifically for sigsuspend(2).  */
2270             if (was_sigsuspended)
2271               {
2272                 current_cpu->thread_data[threadno].sigsuspended = 0;
2273                 for (i = 0; i < 64; i++)
2274                   current_cpu->thread_data[threadno].sigdata[i].blocked
2275                     = current_cpu->thread_data[threadno]
2276                     .sigdata[i].blocked_suspendsave;
2277               }
2278             else
2279               {
2280                 USI sp;
2281                 USI set_low;
2282                 USI set_high;
2283
2284                 (*CPU_REG_FETCH (current_cpu)) (current_cpu,
2285                                             H_GR_SP, regbuf, 4);
2286                 sp = bfd_getl32 (regbuf);
2287                 set_low
2288                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, sp);
2289                 set_high
2290                   = sim_core_read_unaligned_4 (current_cpu, pc, 0, sp + 4);
2291
2292                 for (i = 0; i < 32; i++)
2293                   current_cpu->thread_data[threadno].sigdata[i + 1].blocked
2294                     = (set_low & (1 << i)) != 0;
2295                 for (i = 0; i < 31; i++)
2296                   current_cpu->thread_data[threadno].sigdata[i + 33].blocked
2297                     = (set_high & (1 << i)) != 0;
2298               }
2299
2300             /* The mask changed, so a signal may be unblocked for
2301                execution.  */
2302             current_cpu->thread_data[threadno].sigpending = 1;
2303
2304             memcpy (&current_cpu->cpu_data_placeholder,
2305                     current_cpu->thread_data[threadno].cpu_context_atsignal,
2306                     current_cpu->thread_cpu_data_size);
2307             free (current_cpu->thread_data[threadno].cpu_context_atsignal);
2308             current_cpu->thread_data[threadno].cpu_context_atsignal = NULL;
2309
2310             /* The return value must come from the saved R10.  */
2311             (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_R10, regbuf, 4);
2312             retval = bfd_getl32 (regbuf);
2313
2314             /* We must also break the "sigsuspension loop".  */
2315             if (was_sigsuspended)
2316               sim_pc_set (current_cpu, sim_pc_get (current_cpu) + 2);
2317             break;
2318           }
2319
2320         case TARGET_SYS_rt_sigsuspend:
2321           {
2322             USI newsetp = arg1;
2323             USI setsize = arg2;
2324
2325             if (setsize != 8)
2326               {
2327                 sim_io_eprintf (sd, "Unimplemented rt_sigsuspend syscall"
2328                                " arguments (0x%lx, 0x%lx)\n",
2329                                 (unsigned long) arg1, (unsigned long) arg2);
2330                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2331                                  SIM_SIGILL);
2332               }
2333
2334             /* Don't change the signal mask if we're already in
2335                sigsuspend state (i.e. this syscall is a rerun).  */
2336             else if (!current_cpu->thread_data[threadno].sigsuspended)
2337               {
2338                 USI set_low
2339                   = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2340                                                newsetp);
2341                 USI set_high
2342                   = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2343                                                newsetp + 4);
2344                 int i;
2345
2346                 /* Save the current sigmask and insert the user-supplied
2347                    one.  */
2348                 for (i = 0; i < 32; i++)
2349                   {
2350                     current_cpu->thread_data[threadno]
2351                       .sigdata[i + 1].blocked_suspendsave
2352                       = current_cpu->thread_data[threadno]
2353                       .sigdata[i + 1].blocked;
2354
2355                     current_cpu->thread_data[threadno]
2356                       .sigdata[i + 1].blocked = (set_low & (1 << i)) != 0;
2357                   }
2358                 for (i = 0; i < 31; i++)
2359                   {
2360                     current_cpu->thread_data[threadno]
2361                       .sigdata[i + 33].blocked_suspendsave
2362                       = current_cpu->thread_data[threadno]
2363                       .sigdata[i + 33].blocked;
2364                     current_cpu->thread_data[threadno]
2365                       .sigdata[i + 33].blocked = (set_high & (1 << i)) != 0;
2366                   }
2367
2368                 current_cpu->thread_data[threadno].sigsuspended = 1;
2369
2370                 /* The mask changed, so a signal may be unblocked for
2371                    execution. */
2372                 current_cpu->thread_data[threadno].sigpending = 1;
2373               }
2374
2375             /* Because we don't use arg1 (newsetp) when this syscall is
2376                rerun, it doesn't matter that we overwrite it with the
2377                (constant) return value.  */
2378             retval = -cb_host_to_target_errno (cb, EINTR);
2379             sim_pc_set (current_cpu, pc);
2380             break;
2381           }
2382
2383           /* Add case labels here for other syscalls using the 32-bit
2384              "struct stat", provided they have a corresponding simulator
2385              function of course.  */
2386         case TARGET_SYS_stat:
2387         case TARGET_SYS_fstat:
2388           {
2389             /* As long as the infrastructure doesn't cache anything
2390                related to the stat mapping, this trick gets us a dual
2391                "struct stat"-type mapping in the least error-prone way.  */
2392             const char *saved_map = cb->stat_map;
2393             CB_TARGET_DEFS_MAP *saved_syscall_map = cb->syscall_map;
2394
2395             cb->syscall_map = (CB_TARGET_DEFS_MAP *) syscall_stat32_map;
2396             cb->stat_map = stat32_map;
2397
2398             if (cb_syscall (cb, &s) != CB_RC_OK)
2399               {
2400                 abort ();
2401                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2402                                  SIM_SIGILL);
2403               }
2404             retval = s.result == -1 ? -s.errcode : s.result;
2405
2406             cb->stat_map = saved_map;
2407             cb->syscall_map = saved_syscall_map;
2408             break;
2409           }
2410
2411         case TARGET_SYS_getcwd:
2412           {
2413             USI buf = arg1;
2414             USI size = arg2;
2415
2416             char *cwd = xmalloc (MAXPATHLEN);
2417             if (cwd != getcwd (cwd, MAXPATHLEN))
2418               abort ();
2419
2420             /* FIXME: When and if we support chdir, we need something
2421                a bit more elaborate.  */
2422             if (simulator_sysroot[0] != '\0')
2423               strcpy (cwd, "/");
2424
2425             retval = -cb_host_to_target_errno (cb, ERANGE);
2426             if (strlen (cwd) + 1 <= size)
2427               {
2428                 retval = strlen (cwd) + 1;
2429                 if (sim_core_write_buffer (sd, current_cpu, 0, cwd,
2430                                            buf, retval)
2431                     != (unsigned int) retval)
2432                   retval = -cb_host_to_target_errno (cb, EFAULT);
2433               }
2434             free (cwd);
2435             break;
2436           }
2437
2438         case TARGET_SYS_readlink:
2439           {
2440             SI path = arg1;
2441             SI buf = arg2;
2442             SI bufsiz = arg3;
2443             char *pbuf = xmalloc (MAXPATHLEN);
2444             char *lbuf = xmalloc (MAXPATHLEN);
2445             char *lbuf_alloc = lbuf;
2446             int nchars = -1;
2447             int i;
2448             int o = 0;
2449
2450             if (sim_core_read_unaligned_1 (current_cpu, pc, 0, path) == '/')
2451               {
2452                 strcpy (pbuf, simulator_sysroot);
2453                 o += strlen (simulator_sysroot);
2454               }
2455
2456             for (i = 0; i + o < MAXPATHLEN; i++)
2457               {
2458                 pbuf[i + o]
2459                   = sim_core_read_unaligned_1 (current_cpu, pc, 0, path + i);
2460                 if (pbuf[i + o] == 0)
2461                   break;
2462               }
2463
2464             if (i + o == MAXPATHLEN)
2465               {
2466                 retval = -cb_host_to_target_errno (cb, ENAMETOOLONG);
2467                 break;
2468               }
2469
2470             /* Intervene calls for certain files expected in the target
2471                proc file system.  */
2472             if (strcmp (pbuf + strlen (simulator_sysroot),
2473                         "/proc/" XSTRING (TARGET_PID) "/exe") == 0)
2474               {
2475                 char *argv0
2476                   = (STATE_PROG_ARGV (sd) != NULL
2477                      ? *STATE_PROG_ARGV (sd) : NULL);
2478
2479                 if (argv0 == NULL || *argv0 == '.')
2480                   {
2481                     sim_io_eprintf (sd, "Unimplemented readlink syscall "
2482                                     "(0x%lx: [\"%s\"], 0x%lx)\n",
2483                                     (unsigned long) arg1, pbuf,
2484                                     (unsigned long) arg2);
2485                     sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2486                                      SIM_SIGILL);
2487                     break;
2488                   }
2489                 else if (*argv0 == '/')
2490                   {
2491                     if (strncmp (simulator_sysroot, argv0,
2492                                  strlen (simulator_sysroot)) == 0)
2493                       argv0 += strlen (simulator_sysroot);
2494
2495                     strcpy (lbuf, argv0);
2496                     nchars = strlen (argv0) + 1;
2497                   }
2498                 else
2499                   {
2500                     if (getcwd (lbuf, MAXPATHLEN) != NULL
2501                         && strlen (lbuf) + 2 + strlen (argv0) < MAXPATHLEN)
2502                       {
2503                         if (strncmp (simulator_sysroot, lbuf,
2504                                      strlen (simulator_sysroot)) == 0)
2505                           lbuf += strlen (simulator_sysroot);
2506
2507                         strcat (lbuf, "/");
2508                         strcat (lbuf, argv0);
2509                         nchars = strlen (lbuf) + 1;
2510                       }
2511                     else
2512                       abort ();
2513                   }
2514               }
2515             else
2516               nchars = readlink (pbuf, lbuf, MAXPATHLEN);
2517
2518             /* We trust that the readlink result returns a *relative*
2519                link, or one already adjusted for the file-path-prefix.
2520                (We can't generally tell the difference, so we go with
2521                the easiest decision; no adjustment.)  */
2522
2523             if (nchars == -1)
2524               {
2525                 retval = -cb_host_to_target_errno (cb, errno);
2526                 break;
2527               }
2528
2529             if (bufsiz < nchars)
2530               nchars = bufsiz;
2531
2532             if (sim_core_write_buffer (sd, current_cpu, write_map, lbuf,
2533                                        buf, nchars) != (unsigned int) nchars)
2534               retval = -cb_host_to_target_errno (cb, EFAULT);
2535             else
2536               retval = nchars;
2537
2538             free (pbuf);
2539             free (lbuf_alloc);
2540             break;
2541           }
2542
2543         case TARGET_SYS_sched_getscheduler:
2544           {
2545             USI pid = arg1;
2546
2547             /* FIXME: Search (other) existing threads.  */
2548             if (pid != 0 && pid != TARGET_PID)
2549               retval = -cb_host_to_target_errno (cb, ESRCH);
2550             else
2551               retval = TARGET_SCHED_OTHER;
2552             break;
2553           }
2554
2555         case TARGET_SYS_sched_getparam:
2556           {
2557             USI pid = arg1;
2558             USI paramp = arg2;
2559
2560             /* The kernel says:
2561                struct sched_param {
2562                         int sched_priority;
2563                }; */
2564
2565             if (pid != 0 && pid != TARGET_PID)
2566               retval = -cb_host_to_target_errno (cb, ESRCH);
2567             else
2568               {
2569                 /* FIXME: Save scheduler setting before threads are
2570                    created too.  */
2571                 sim_core_write_unaligned_4 (current_cpu, pc, 0, paramp,
2572                                             current_cpu->thread_data != NULL
2573                                             ? (current_cpu
2574                                                ->thread_data[threadno]
2575                                                .priority)
2576                                             : 0);
2577                 retval = 0;
2578               }
2579             break;
2580           }
2581
2582         case TARGET_SYS_sched_setparam:
2583           {
2584             USI pid = arg1;
2585             USI paramp = arg2;
2586
2587             if ((pid != 0 && pid != TARGET_PID)
2588                 || sim_core_read_unaligned_4 (current_cpu, pc, 0,
2589                                               paramp) != 0)
2590               retval = -cb_host_to_target_errno (cb, EINVAL);
2591             else
2592               retval = 0;
2593             break;
2594           }
2595
2596         case TARGET_SYS_sched_setscheduler:
2597           {
2598             USI pid = arg1;
2599             USI policy = arg2;
2600             USI paramp = arg3;
2601
2602             if ((pid != 0 && pid != TARGET_PID)
2603                 || policy != TARGET_SCHED_OTHER
2604                 || sim_core_read_unaligned_4 (current_cpu, pc, 0,
2605                                               paramp) != 0)
2606               retval = -cb_host_to_target_errno (cb, EINVAL);
2607             else
2608               /* FIXME: Save scheduler setting to be read in later
2609                  sched_getparam calls.  */
2610               retval = 0;
2611             break;
2612           }
2613
2614         case TARGET_SYS_sched_yield:
2615           /* We reschedule to the next thread after a syscall anyway, so
2616              we don't have to do anything here than to set the return
2617              value.  */
2618           retval = 0;
2619           break;
2620
2621         case TARGET_SYS_sched_get_priority_min:
2622         case TARGET_SYS_sched_get_priority_max:
2623           if (arg1 != 0)
2624             retval = -cb_host_to_target_errno (cb, EINVAL);
2625           else
2626             retval = 0;
2627           break;
2628
2629         case TARGET_SYS_ugetrlimit:
2630           {
2631             unsigned int curlim, maxlim;
2632             if (arg1 != TARGET_RLIMIT_STACK && arg1 != TARGET_RLIMIT_NOFILE)
2633               {
2634                 retval = -cb_host_to_target_errno (cb, EINVAL);
2635                 break;
2636               }
2637
2638             /* The kernel says:
2639                struct rlimit {
2640                        unsigned long   rlim_cur;
2641                        unsigned long   rlim_max;
2642                }; */
2643             if (arg1 == TARGET_RLIMIT_NOFILE)
2644               {
2645                 /* Sadly a very low limit.  Better not lie, though.  */
2646                 maxlim = curlim = MAX_CALLBACK_FDS;
2647               }
2648             else /* arg1 == TARGET_RLIMIT_STACK */
2649               {
2650                 maxlim = 0xffffffff;
2651                 curlim = 0x800000;
2652               }
2653             sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2, curlim);
2654             sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2 + 4, maxlim);
2655             retval = 0;
2656             break;
2657           }
2658
2659         case TARGET_SYS_setrlimit:
2660           if (arg1 != TARGET_RLIMIT_STACK)
2661             {
2662               retval = -cb_host_to_target_errno (cb, EINVAL);
2663               break;
2664             }
2665           /* FIXME: Save values for future ugetrlimit calls.  */
2666           retval = 0;
2667           break;
2668
2669         /* Provide a very limited subset of the sysctl functions, and
2670            abort for the rest. */
2671         case TARGET_SYS__sysctl:
2672           {
2673             /* The kernel says:
2674                struct __sysctl_args {
2675                 int *name;
2676                 int nlen;
2677                 void *oldval;
2678                 size_t *oldlenp;
2679                 void *newval;
2680                 size_t newlen;
2681                 unsigned long __unused[4];
2682                }; */
2683             SI name = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1);
2684             SI name0 = name == 0
2685               ? 0 : sim_core_read_unaligned_4 (current_cpu, pc, 0, name);
2686             SI name1 = name == 0
2687               ? 0 : sim_core_read_unaligned_4 (current_cpu, pc, 0, name + 4);
2688             SI nlen
2689               =  sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 4);
2690             SI oldval
2691               =  sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 8);
2692             SI oldlenp
2693               =  sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 12);
2694             SI oldlen = oldlenp == 0
2695               ? 0 : sim_core_read_unaligned_4 (current_cpu, pc, 0, oldlenp);
2696             SI newval
2697               =  sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 16);
2698             SI newlen
2699               = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 20);
2700
2701             if (name0 == TARGET_CTL_KERN && name1 == TARGET_CTL_KERN_VERSION)
2702               {
2703                 SI to_write = oldlen < (SI) sizeof (TARGET_UTSNAME)
2704                   ? oldlen : (SI) sizeof (TARGET_UTSNAME);
2705
2706                 sim_core_write_unaligned_4 (current_cpu, pc, 0, oldlenp,
2707                                             sizeof (TARGET_UTSNAME));
2708
2709                 if (sim_core_write_buffer (sd, current_cpu, write_map,
2710                                            TARGET_UTSNAME, oldval,
2711                                            to_write)
2712                     != (unsigned int) to_write)
2713                   retval = -cb_host_to_target_errno (cb, EFAULT);
2714                 else
2715                   retval = 0;
2716                 break;
2717               }
2718
2719             sim_io_eprintf (sd, "Unimplemented _sysctl syscall "
2720                             "(0x%lx: [0x%lx, 0x%lx],"
2721                             " 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
2722                             (unsigned long) name,
2723                             (unsigned long) name0,
2724                             (unsigned long) name1,
2725                             (unsigned long) nlen,
2726                             (unsigned long) oldval,
2727                             (unsigned long) oldlenp,
2728                             (unsigned long) newval,
2729                             (unsigned long) newlen);
2730             sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2731                              SIM_SIGILL);
2732             break;
2733           }
2734
2735         case TARGET_SYS_exit:
2736           {
2737             /* Here for all but the last thread.  */
2738             int i;
2739             int pid
2740               = current_cpu->thread_data[threadno].threadid + TARGET_PID;
2741             int ppid
2742               = (current_cpu->thread_data[threadno].parent_threadid
2743                  + TARGET_PID);
2744             int exitsig = current_cpu->thread_data[threadno].exitsig;
2745
2746             /* Any children are now all orphans.  */
2747             for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
2748               if (current_cpu->thread_data[i].parent_threadid
2749                   == current_cpu->thread_data[threadno].threadid)
2750                 /* Make getppid(2) return 1 for them, poor little ones.  */
2751                 current_cpu->thread_data[i].parent_threadid = -TARGET_PID + 1;
2752
2753             /* Free the cpu context data.  When the parent has received
2754                the exit status, we'll clear the entry too.  */
2755             free (current_cpu->thread_data[threadno].cpu_context);
2756             current_cpu->thread_data[threadno].cpu_context = NULL;
2757             current_cpu->m1threads--;
2758             if (arg1 != 0)
2759               {
2760                 sim_io_eprintf (sd, "Thread %d exited with status %d\n",
2761                                 pid, arg1);
2762                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2763                                  SIM_SIGILL);
2764               }
2765
2766             /* Still, we may want to support non-zero exit values.  */
2767             current_cpu->thread_data[threadno].exitval = arg1 << 8;
2768
2769             if (exitsig)
2770               deliver_signal (current_cpu, exitsig, ppid);
2771             break;
2772           }
2773
2774         case TARGET_SYS_clone:
2775           {
2776             int nthreads = current_cpu->m1threads + 1;
2777             void *thread_cpu_data;
2778             bfd_byte old_sp_buf[4];
2779             bfd_byte sp_buf[4];
2780             const bfd_byte zeros[4] = { 0, 0, 0, 0 };
2781             int i;
2782
2783             /* That's right, the syscall clone arguments are reversed
2784                compared to sys_clone notes in clone(2) and compared to
2785                other Linux ports (i.e. it's the same order as in the
2786                clone(2) libcall).  */
2787             USI flags = arg2;
2788             USI newsp = arg1;
2789
2790             if (nthreads == SIM_TARGET_MAX_THREADS)
2791               {
2792                 retval = -cb_host_to_target_errno (cb, EAGAIN);
2793                 break;
2794               }
2795
2796             /* FIXME: Implement the low byte.  */
2797             if ((flags & ~TARGET_CSIGNAL) !=
2798                 (TARGET_CLONE_VM
2799                  | TARGET_CLONE_FS
2800                  | TARGET_CLONE_FILES
2801                  | TARGET_CLONE_SIGHAND)
2802                 || newsp == 0)
2803               {
2804                 sim_io_eprintf (sd,
2805                                 "Unimplemented clone syscall (0x%lx, 0x%lx)\n",
2806                                 (unsigned long) arg1, (unsigned long) arg2);
2807                 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2808                                  SIM_SIGILL);
2809               }
2810
2811             if (current_cpu->thread_data == NULL)
2812               make_first_thread (current_cpu);
2813
2814             /* The created thread will get the new SP and a cleared R10.
2815                Since it's created out of a copy of the old thread and we
2816                don't have a set-register-function that just take the
2817                cpu_data as a parameter, we set the childs values first,
2818                and write back or overwrite them in the parent after the
2819                copy.  */
2820             (*CPU_REG_FETCH (current_cpu)) (current_cpu,
2821                                             H_GR_SP, old_sp_buf, 4);
2822             bfd_putl32 (newsp, sp_buf);
2823             (*CPU_REG_STORE (current_cpu)) (current_cpu,
2824                                             H_GR_SP, sp_buf, 4);
2825             (*CPU_REG_STORE (current_cpu)) (current_cpu,
2826                                             H_GR_R10, (bfd_byte *) zeros, 4);
2827             thread_cpu_data
2828               = (*current_cpu
2829                  ->make_thread_cpu_data) (current_cpu,
2830                                           &current_cpu->cpu_data_placeholder);
2831             (*CPU_REG_STORE (current_cpu)) (current_cpu,
2832                                             H_GR_SP, old_sp_buf, 4);
2833
2834             retval = ++current_cpu->max_threadid + TARGET_PID;
2835
2836             /* Find an unused slot.  After a few threads have been created
2837                and exited, the array is expected to be a bit fragmented.
2838                We don't reuse the first entry, though, that of the
2839                original thread.  */
2840             for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
2841               if (current_cpu->thread_data[i].cpu_context == NULL
2842                   /* Don't reuse a zombied entry.  */
2843                   && current_cpu->thread_data[i].threadid == 0)
2844                 break;
2845
2846             memcpy (&current_cpu->thread_data[i],
2847                     &current_cpu->thread_data[threadno],
2848                     sizeof (current_cpu->thread_data[i]));
2849             current_cpu->thread_data[i].cpu_context = thread_cpu_data;
2850             current_cpu->thread_data[i].cpu_context_atsignal = NULL;
2851             current_cpu->thread_data[i].threadid = current_cpu->max_threadid;
2852             current_cpu->thread_data[i].parent_threadid
2853               = current_cpu->thread_data[threadno].threadid;
2854             current_cpu->thread_data[i].pipe_read_fd = 0;
2855             current_cpu->thread_data[i].pipe_write_fd = 0;
2856             current_cpu->thread_data[i].at_syscall = 0;
2857             current_cpu->thread_data[i].sigpending = 0;
2858             current_cpu->thread_data[i].sigsuspended = 0;
2859             current_cpu->thread_data[i].exitsig = flags & TARGET_CSIGNAL;
2860             current_cpu->m1threads = nthreads;
2861             break;
2862           }
2863
2864         /* Better watch these in case they do something necessary.  */
2865         case TARGET_SYS_socketcall:
2866           retval = -cb_host_to_target_errno (cb, ENOSYS);
2867           break;
2868
2869         unimplemented_syscall:
2870         default:
2871           sim_io_eprintf (sd, "Unimplemented syscall: %d "
2872                           "(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n", callnum,
2873                           arg1, arg2, arg3, arg4, arg5, arg6);
2874           sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2875                            SIM_SIGILL);
2876         }
2877     }
2878
2879   /* Minimal support for fcntl F_GETFL as used in open+fdopen.  */
2880   if (callnum == TARGET_SYS_open)
2881     {
2882       current_cpu->last_open_fd = retval;
2883       current_cpu->last_open_flags = arg2;
2884     }
2885   current_cpu->last_syscall = callnum;
2886
2887   /* A system call is a rescheduling point.  For the time being, we don't
2888      reschedule anywhere else.  */
2889   if (current_cpu->m1threads != 0
2890       /* We need to schedule off from an exiting thread that is the
2891          second-last one.  */
2892       || (current_cpu->thread_data != NULL
2893           && current_cpu->thread_data[threadno].cpu_context == NULL))
2894     {
2895       bfd_byte retval_buf[4];
2896
2897       current_cpu->thread_data[threadno].last_execution
2898         = TARGET_TIME_MS (current_cpu);
2899       bfd_putl32 (retval, retval_buf);
2900       (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R10, retval_buf, 4);
2901
2902       current_cpu->thread_data[threadno].at_syscall = 1;
2903       reschedule (current_cpu);
2904
2905       (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_R10, retval_buf, 4);
2906       retval = bfd_getl32 (retval_buf);
2907     }
2908
2909   return retval;
2910 }
2911
2912 /* Callback from simulator write saying that the pipe at (reader, writer)
2913    is now non-empty (so the writer should wait until the pipe is empty, at
2914    least not write to this or any other pipe).  Simplest is to just wait
2915    until the pipe is empty.  */
2916
2917 static void
2918 cris_pipe_nonempty (host_callback *cb ATTRIBUTE_UNUSED,
2919                     int reader, int writer)
2920 {
2921   SIM_CPU *cpu = current_cpu_for_cb_callback;
2922   const bfd_byte zeros[4] = { 0, 0, 0, 0 };
2923
2924   /* It's the current thread: we just have to re-run the current
2925      syscall instruction (presumably "break 13") and change the syscall
2926      to the special simulator-wait code.  Oh, and set a marker that
2927      we're waiting, so we can disambiguate the special call from a
2928      program error.
2929
2930      This function may be called multiple times between cris_pipe_empty,
2931      but we must avoid e.g. decreasing PC every time.  Check fd markers
2932      to tell.  */
2933   if (cpu->thread_data == NULL)
2934     {
2935       sim_io_eprintf (CPU_STATE (cpu),
2936                       "Terminating simulation due to writing pipe rd:wr %d:%d"
2937                       " from one single thread\n", reader, writer);
2938       sim_engine_halt (CPU_STATE (cpu), cpu,
2939                        NULL, sim_pc_get (cpu), sim_stopped, SIM_SIGILL);
2940     }
2941   else if (cpu->thread_data[cpu->threadno].pipe_write_fd == 0)
2942     {
2943       cpu->thread_data[cpu->threadno].pipe_write_fd = writer;
2944       cpu->thread_data[cpu->threadno].pipe_read_fd = reader;
2945       /* FIXME: We really shouldn't change registers other than R10 in
2946          syscalls (like R9), here or elsewhere.  */
2947       (*CPU_REG_STORE (cpu)) (cpu, H_GR_R9, (bfd_byte *) zeros, 4);
2948       sim_pc_set (cpu, sim_pc_get (cpu) - 2);
2949     }
2950 }
2951
2952 /* Callback from simulator close or read call saying that the pipe at
2953    (reader, writer) is now empty (so the writer can write again, perhaps
2954    leave a waiting state).  If there are bytes remaining, they couldn't be
2955    consumed (perhaps due to the pipe closing).  */
2956
2957 static void
2958 cris_pipe_empty (host_callback *cb,
2959                  int reader ATTRIBUTE_UNUSED,
2960                  int writer)
2961 {
2962   int i;
2963   SIM_CPU *cpu = current_cpu_for_cb_callback;
2964   bfd_byte r10_buf[4];
2965   int remaining = cb->pipe_buffer[writer].size;
2966
2967   /* We need to find the thread that waits for this pipe.  */
2968   for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
2969     if (cpu->thread_data[i].cpu_context
2970         && cpu->thread_data[i].pipe_write_fd == writer)
2971       {
2972         int retval;
2973         /* Temporarily switch to this cpu context, so we can change the
2974            PC by ordinary calls.  */
2975
2976         memcpy (cpu->thread_data[cpu->threadno].cpu_context,
2977                 &cpu->cpu_data_placeholder,
2978                 cpu->thread_cpu_data_size);
2979         memcpy (&cpu->cpu_data_placeholder,
2980                 cpu->thread_data[i].cpu_context,
2981                 cpu->thread_cpu_data_size);
2982
2983         /* The return value is supposed to contain the number of written
2984            bytes, which is the number of bytes requested and returned at
2985            the write call.  We subtract the remaining bytes from that,
2986            but making sure we still get a positive number.
2987            The return value may also be a negative number; an error
2988            value.  We cover this case by comparing against remaining,
2989            which is always >= 0.  */
2990         (*CPU_REG_FETCH (cpu)) (cpu, H_GR_R10, r10_buf, 4);
2991         retval = (int) bfd_getl_signed_32 (r10_buf);
2992         if (retval >= remaining)
2993           bfd_putl32 (retval - remaining, r10_buf);
2994         (*CPU_REG_STORE (cpu)) (cpu, H_GR_R10, r10_buf, 4);
2995
2996         sim_pc_set (cpu, sim_pc_get (cpu) + 2);
2997         memcpy (cpu->thread_data[i].cpu_context,
2998                 &cpu->cpu_data_placeholder,
2999                 cpu->thread_cpu_data_size);
3000         memcpy (&cpu->cpu_data_placeholder,
3001                 cpu->thread_data[cpu->threadno].cpu_context,
3002                 cpu->thread_cpu_data_size);
3003         cpu->thread_data[i].pipe_read_fd = 0;
3004         cpu->thread_data[i].pipe_write_fd = 0;
3005         return;
3006       }
3007
3008   abort ();
3009 }
3010
3011 /* We have a simulator-specific notion of time.  See TARGET_TIME.  */
3012
3013 static long
3014 cris_time (host_callback *cb ATTRIBUTE_UNUSED, long *t)
3015 {
3016   long retval = TARGET_TIME (current_cpu_for_cb_callback);
3017   if (t)
3018     *t = retval;
3019   return retval;
3020 }
3021
3022 /* Set target-specific callback data. */
3023
3024 void
3025 cris_set_callbacks (host_callback *cb)
3026 {
3027   /* Yeargh, have to cast away constness to avoid warnings.  */
3028   cb->syscall_map = (CB_TARGET_DEFS_MAP *) syscall_map;
3029   cb->errno_map = (CB_TARGET_DEFS_MAP *) errno_map;
3030
3031   /* The kernel stat64 layout.  If we see a file > 2G, the "long"
3032      parameter to cb_store_target_endian will make st_size negative.
3033      Similarly for st_ino.  FIXME: Find a 64-bit type, and use it
3034      *unsigned*, and/or add syntax for signed-ness.  */
3035   cb->stat_map = stat_map;
3036   cb->open_map = (CB_TARGET_DEFS_MAP *) open_map;
3037   cb->pipe_nonempty = cris_pipe_nonempty;
3038   cb->pipe_empty = cris_pipe_empty;
3039   cb->time = cris_time;
3040 }
3041
3042 /* Process an address exception.  */
3043
3044 void
3045 cris_core_signal (SIM_DESC sd, SIM_CPU *current_cpu, sim_cia cia,
3046                   unsigned int map, int nr_bytes, address_word addr,
3047                   transfer_type transfer, sim_core_signals sig)
3048 {
3049   sim_core_signal (sd, current_cpu, cia, map, nr_bytes, addr,
3050                    transfer, sig);
3051 }