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