sim/cris/traps.c

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