sim/cris/traps.c

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