contrib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cc

   1 //===-- sanitizer_linux.cc ------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between AddressSanitizer and ThreadSanitizer
  11 // run-time libraries and implements linux-specific functions from
  12 // sanitizer_libc.h.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "sanitizer_platform.h"
  16
  17 #if SANITIZER_FREEBSD || SANITIZER_LINUX
  18
  19 #include "sanitizer_common.h"
  20 #include "sanitizer_flags.h"
  21 #include "sanitizer_internal_defs.h"
  22 #include "sanitizer_libc.h"
  23 #include "sanitizer_linux.h"
  24 #include "sanitizer_mutex.h"
  25 #include "sanitizer_placement_new.h"
  26 #include "sanitizer_procmaps.h"
  27 #include "sanitizer_stacktrace.h"
  28 #include "sanitizer_symbolizer.h"
  29
  30 #if !SANITIZER_FREEBSD
  31 #include <asm/param.h>
  32 #endif
  33
  34 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
  35 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
  36 // access stat from asm/stat.h, without conflicting with definition in
  37 // sys/stat.h, we use this trick.
  38 #if defined(__mips64)
  39 #include <asm/unistd.h>
  40 #include <sys/types.h>
  41 #define stat kernel_stat
  42 #include <asm/stat.h>
  43 #undef stat
  44 #endif
  45
  46 #include <dlfcn.h>
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #include <link.h>
  50 #include <pthread.h>
  51 #include <sched.h>
  52 #include <sys/mman.h>
  53 #include <sys/ptrace.h>
  54 #include <sys/resource.h>
  55 #include <sys/stat.h>
  56 #include <sys/syscall.h>
  57 #include <sys/time.h>
  58 #include <sys/types.h>
  59 #include <ucontext.h>
  60 #include <unistd.h>
  61
  62 #if SANITIZER_FREEBSD
  63 #include <sys/sysctl.h>
  64 #include <machine/atomic.h>
  65 extern "C" {
  66 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on
  67 // FreeBSD 9.2 and 10.0.
  68 #include <sys/umtx.h>
  69 }
  70 extern char **environ;  // provided by crt1
  71 #endif  // SANITIZER_FREEBSD
  72
  73 #if !SANITIZER_ANDROID
  74 #include <sys/signal.h>
  75 #endif
  76
  77 #if SANITIZER_LINUX
  78 // <linux/time.h>
  79 struct kernel_timeval {
  80   long tv_sec;
  81   long tv_usec;
  82 };
  83
  84 // <linux/futex.h> is broken on some linux distributions.
  85 const int FUTEX_WAIT = 0;
  86 const int FUTEX_WAKE = 1;
  87 #endif  // SANITIZER_LINUX
  88
  89 // Are we using 32-bit or 64-bit Linux syscalls?
  90 // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
  91 // but it still needs to use 64-bit syscalls.
  92 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
  93     SANITIZER_WORDSIZE == 64)
  94 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
  95 #else
  96 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
  97 #endif
  98
  99 namespace __sanitizer {
 100
 101 #if SANITIZER_LINUX && defined(__x86_64__)
 102 #include "sanitizer_syscall_linux_x86_64.inc"
 103 #elif SANITIZER_LINUX && defined(__aarch64__)
 104 #include "sanitizer_syscall_linux_aarch64.inc"
 105 #else
 106 #include "sanitizer_syscall_generic.inc"
 107 #endif
 108
 109 // --------------- sanitizer_libc.h
 110 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
 111                    OFF_T offset) {
 112 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
 113   return internal_syscall(SYSCALL(mmap), (uptr)addr, length, prot, flags, fd,
 114                           offset);
 115 #else
 116   // mmap2 specifies file offset in 4096-byte units.
 117   CHECK(IsAligned(offset, 4096));
 118   return internal_syscall(SYSCALL(mmap2), addr, length, prot, flags, fd,
 119                           offset / 4096);
 120 #endif
 121 }
 122
 123 uptr internal_munmap(void *addr, uptr length) {
 124   return internal_syscall(SYSCALL(munmap), (uptr)addr, length);
 125 }
 126
 127 int internal_mprotect(void *addr, uptr length, int prot) {
 128   return internal_syscall(SYSCALL(mprotect), (uptr)addr, length, prot);
 129 }
 130
 131 uptr internal_close(fd_t fd) {
 132   return internal_syscall(SYSCALL(close), fd);
 133 }
 134
 135 uptr internal_open(const char *filename, int flags) {
 136 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 137   return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags);
 138 #else
 139   return internal_syscall(SYSCALL(open), (uptr)filename, flags);
 140 #endif
 141 }
 142
 143 uptr internal_open(const char *filename, int flags, u32 mode) {
 144 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 145   return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags,
 146                           mode);
 147 #else
 148   return internal_syscall(SYSCALL(open), (uptr)filename, flags, mode);
 149 #endif
 150 }
 151
 152 uptr internal_read(fd_t fd, void *buf, uptr count) {
 153   sptr res;
 154   HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(read), fd, (uptr)buf,
 155                count));
 156   return res;
 157 }
 158
 159 uptr internal_write(fd_t fd, const void *buf, uptr count) {
 160   sptr res;
 161   HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(write), fd, (uptr)buf,
 162                count));
 163   return res;
 164 }
 165
 166 uptr internal_ftruncate(fd_t fd, uptr size) {
 167   sptr res;
 168   HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate), fd,
 169                (OFF_T)size));
 170   return res;
 171 }
 172
 173 #if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && !SANITIZER_FREEBSD
 174 static void stat64_to_stat(struct stat64 *in, struct stat *out) {
 175   internal_memset(out, 0, sizeof(*out));
 176   out->st_dev = in->st_dev;
 177   out->st_ino = in->st_ino;
 178   out->st_mode = in->st_mode;
 179   out->st_nlink = in->st_nlink;
 180   out->st_uid = in->st_uid;
 181   out->st_gid = in->st_gid;
 182   out->st_rdev = in->st_rdev;
 183   out->st_size = in->st_size;
 184   out->st_blksize = in->st_blksize;
 185   out->st_blocks = in->st_blocks;
 186   out->st_atime = in->st_atime;
 187   out->st_mtime = in->st_mtime;
 188   out->st_ctime = in->st_ctime;
 189   out->st_ino = in->st_ino;
 190 }
 191 #endif
 192
 193 #if defined(__mips64)
 194 static void kernel_stat_to_stat(struct kernel_stat *in, struct stat *out) {
 195   internal_memset(out, 0, sizeof(*out));
 196   out->st_dev = in->st_dev;
 197   out->st_ino = in->st_ino;
 198   out->st_mode = in->st_mode;
 199   out->st_nlink = in->st_nlink;
 200   out->st_uid = in->st_uid;
 201   out->st_gid = in->st_gid;
 202   out->st_rdev = in->st_rdev;
 203   out->st_size = in->st_size;
 204   out->st_blksize = in->st_blksize;
 205   out->st_blocks = in->st_blocks;
 206   out->st_atime = in->st_atime_nsec;
 207   out->st_mtime = in->st_mtime_nsec;
 208   out->st_ctime = in->st_ctime_nsec;
 209   out->st_ino = in->st_ino;
 210 }
 211 #endif
 212
 213 uptr internal_stat(const char *path, void *buf) {
 214 #if SANITIZER_FREEBSD
 215   return internal_syscall(SYSCALL(stat), path, buf);
 216 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 217   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
 218                           (uptr)buf, 0);
 219 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
 220 # if defined(__mips64)
 221   // For mips64, stat syscall fills buffer in the format of kernel_stat
 222   struct kernel_stat kbuf;
 223   int res = internal_syscall(SYSCALL(stat), path, &kbuf);
 224   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
 225   return res;
 226 # else
 227   return internal_syscall(SYSCALL(stat), (uptr)path, (uptr)buf);
 228 # endif
 229 #else
 230   struct stat64 buf64;
 231   int res = internal_syscall(SYSCALL(stat64), path, &buf64);
 232   stat64_to_stat(&buf64, (struct stat *)buf);
 233   return res;
 234 #endif
 235 }
 236
 237 uptr internal_lstat(const char *path, void *buf) {
 238 #if SANITIZER_FREEBSD
 239   return internal_syscall(SYSCALL(lstat), path, buf);
 240 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 241   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
 242                          (uptr)buf, AT_SYMLINK_NOFOLLOW);
 243 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
 244   return internal_syscall(SYSCALL(lstat), (uptr)path, (uptr)buf);
 245 #else
 246   struct stat64 buf64;
 247   int res = internal_syscall(SYSCALL(lstat64), path, &buf64);
 248   stat64_to_stat(&buf64, (struct stat *)buf);
 249   return res;
 250 #endif
 251 }
 252
 253 uptr internal_fstat(fd_t fd, void *buf) {
 254 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
 255   return internal_syscall(SYSCALL(fstat), fd, (uptr)buf);
 256 #else
 257   struct stat64 buf64;
 258   int res = internal_syscall(SYSCALL(fstat64), fd, &buf64);
 259   stat64_to_stat(&buf64, (struct stat *)buf);
 260   return res;
 261 #endif
 262 }
 263
 264 uptr internal_filesize(fd_t fd) {
 265   struct stat st;
 266   if (internal_fstat(fd, &st))
 267     return -1;
 268   return (uptr)st.st_size;
 269 }
 270
 271 uptr internal_dup2(int oldfd, int newfd) {
 272 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 273   return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0);
 274 #else
 275   return internal_syscall(SYSCALL(dup2), oldfd, newfd);
 276 #endif
 277 }
 278
 279 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
 280 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 281   return internal_syscall(SYSCALL(readlinkat), AT_FDCWD,
 282                           (uptr)path, (uptr)buf, bufsize);
 283 #else
 284   return internal_syscall(SYSCALL(readlink), (uptr)path, (uptr)buf, bufsize);
 285 #endif
 286 }
 287
 288 uptr internal_unlink(const char *path) {
 289 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 290   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
 291 #else
 292   return internal_syscall(SYSCALL(unlink), (uptr)path);
 293 #endif
 294 }
 295
 296 uptr internal_rename(const char *oldpath, const char *newpath) {
 297 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 298   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
 299                           (uptr)newpath);
 300 #else
 301   return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
 302 #endif
 303 }
 304
 305 uptr internal_sched_yield() {
 306   return internal_syscall(SYSCALL(sched_yield));
 307 }
 308
 309 void internal__exit(int exitcode) {
 310 #if SANITIZER_FREEBSD
 311   internal_syscall(SYSCALL(exit), exitcode);
 312 #else
 313   internal_syscall(SYSCALL(exit_group), exitcode);
 314 #endif
 315   Die();  // Unreachable.
 316 }
 317
 318 uptr internal_execve(const char *filename, char *const argv[],
 319                      char *const envp[]) {
 320   return internal_syscall(SYSCALL(execve), (uptr)filename, (uptr)argv,
 321                           (uptr)envp);
 322 }
 323
 324 // ----------------- sanitizer_common.h
 325 bool FileExists(const char *filename) {
 326   struct stat st;
 327 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 328   if (internal_syscall(SYSCALL(newfstatat), AT_FDCWD, filename, &st, 0))
 329 #else
 330   if (internal_stat(filename, &st))
 331 #endif
 332     return false;
 333   // Sanity check: filename is a regular file.
 334   return S_ISREG(st.st_mode);
 335 }
 336
 337 uptr GetTid() {
 338 #if SANITIZER_FREEBSD
 339   return (uptr)pthread_self();
 340 #else
 341   return internal_syscall(SYSCALL(gettid));
 342 #endif
 343 }
 344
 345 u64 NanoTime() {
 346 #if SANITIZER_FREEBSD
 347   timeval tv;
 348 #else
 349   kernel_timeval tv;
 350 #endif
 351   internal_memset(&tv, 0, sizeof(tv));
 352   internal_syscall(SYSCALL(gettimeofday), (uptr)&tv, 0);
 353   return (u64)tv.tv_sec * 1000*1000*1000 + tv.tv_usec * 1000;
 354 }
 355
 356 // Like getenv, but reads env directly from /proc (on Linux) or parses the
 357 // 'environ' array (on FreeBSD) and does not use libc. This function should be
 358 // called first inside __asan_init.
 359 const char *GetEnv(const char *name) {
 360 #if SANITIZER_FREEBSD
 361   if (::environ != 0) {
 362     uptr NameLen = internal_strlen(name);
 363     for (char **Env = ::environ; *Env != 0; Env++) {
 364       if (internal_strncmp(*Env, name, NameLen) == 0 && (*Env)[NameLen] == '=')
 365         return (*Env) + NameLen + 1;
 366     }
 367   }
 368   return 0;  // Not found.
 369 #elif SANITIZER_LINUX
 370   static char *environ;
 371   static uptr len;
 372   static bool inited;
 373   if (!inited) {
 374     inited = true;
 375     uptr environ_size;
 376     if (!ReadFileToBuffer("/proc/self/environ", &environ, &environ_size, &len))
 377       environ = nullptr;
 378   }
 379   if (!environ || len == 0) return nullptr;
 380   uptr namelen = internal_strlen(name);
 381   const char *p = environ;
 382   while (*p != '\0') {  // will happen at the \0\0 that terminates the buffer
 383     // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
 384     const char* endp =
 385         (char*)internal_memchr(p, '\0', len - (p - environ));
 386     if (!endp)  // this entry isn't NUL terminated
 387       return nullptr;
 388     else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=')  // Match.
 389       return p + namelen + 1;  // point after =
 390     p = endp + 1;
 391   }
 392   return nullptr;  // Not found.
 393 #else
 394 #error "Unsupported platform"
 395 #endif
 396 }
 397
 398 extern "C" {
 399   SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end;
 400 }
 401
 402 #if !SANITIZER_GO
 403 static void ReadNullSepFileToArray(const char *path, char ***arr,
 404                                    int arr_size) {
 405   char *buff;
 406   uptr buff_size;
 407   uptr buff_len;
 408   *arr = (char **)MmapOrDie(arr_size * sizeof(char *), "NullSepFileArray");
 409   if (!ReadFileToBuffer(path, &buff, &buff_size, &buff_len, 1024 * 1024)) {
 410     (*arr)[0] = nullptr;
 411     return;
 412   }
 413   (*arr)[0] = buff;
 414   int count, i;
 415   for (count = 1, i = 1; ; i++) {
 416     if (buff[i] == 0) {
 417       if (buff[i+1] == 0) break;
 418       (*arr)[count] = &buff[i+1];
 419       CHECK_LE(count, arr_size - 1);  // FIXME: make this more flexible.
 420       count++;
 421     }
 422   }
 423   (*arr)[count] = nullptr;
 424 }
 425 #endif
 426
 427 static void GetArgsAndEnv(char*** argv, char*** envp) {
 428 #if !SANITIZER_GO
 429   if (&__libc_stack_end) {
 430 #endif
 431     uptr* stack_end = (uptr*)__libc_stack_end;
 432     int argc = *stack_end;
 433     *argv = (char**)(stack_end + 1);
 434     *envp = (char**)(stack_end + argc + 2);
 435 #if !SANITIZER_GO
 436   } else {
 437     static const int kMaxArgv = 2000, kMaxEnvp = 2000;
 438     ReadNullSepFileToArray("/proc/self/cmdline", argv, kMaxArgv);
 439     ReadNullSepFileToArray("/proc/self/environ", envp, kMaxEnvp);
 440   }
 441 #endif
 442 }
 443
 444 void ReExec() {
 445   char **argv, **envp;
 446   GetArgsAndEnv(&argv, &envp);
 447   uptr rv = internal_execve("/proc/self/exe", argv, envp);
 448   int rverrno;
 449   CHECK_EQ(internal_iserror(rv, &rverrno), true);
 450   Printf("execve failed, errno %d\n", rverrno);
 451   Die();
 452 }
 453
 454 enum MutexState {
 455   MtxUnlocked = 0,
 456   MtxLocked = 1,
 457   MtxSleeping = 2
 458 };
 459
 460 BlockingMutex::BlockingMutex() {
 461   internal_memset(this, 0, sizeof(*this));
 462 }
 463
 464 void BlockingMutex::Lock() {
 465   CHECK_EQ(owner_, 0);
 466   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
 467   if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked)
 468     return;
 469   while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) {
 470 #if SANITIZER_FREEBSD
 471     _umtx_op(m, UMTX_OP_WAIT_UINT, MtxSleeping, 0, 0);
 472 #else
 473     internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAIT, MtxSleeping, 0, 0, 0);
 474 #endif
 475   }
 476 }
 477
 478 void BlockingMutex::Unlock() {
 479   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
 480   u32 v = atomic_exchange(m, MtxUnlocked, memory_order_relaxed);
 481   CHECK_NE(v, MtxUnlocked);
 482   if (v == MtxSleeping) {
 483 #if SANITIZER_FREEBSD
 484     _umtx_op(m, UMTX_OP_WAKE, 1, 0, 0);
 485 #else
 486     internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAKE, 1, 0, 0, 0);
 487 #endif
 488   }
 489 }
 490
 491 void BlockingMutex::CheckLocked() {
 492   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
 493   CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed));
 494 }
 495
 496 // ----------------- sanitizer_linux.h
 497 // The actual size of this structure is specified by d_reclen.
 498 // Note that getdents64 uses a different structure format. We only provide the
 499 // 32-bit syscall here.
 500 struct linux_dirent {
 501 #if SANITIZER_X32 || defined(__aarch64__)
 502   u64 d_ino;
 503   u64 d_off;
 504 #else
 505   unsigned long      d_ino;
 506   unsigned long      d_off;
 507 #endif
 508   unsigned short     d_reclen;
 509 #ifdef __aarch64__
 510   unsigned char      d_type;
 511 #endif
 512   char               d_name[256];
 513 };
 514
 515 // Syscall wrappers.
 516 uptr internal_ptrace(int request, int pid, void *addr, void *data) {
 517   return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr,
 518                           (uptr)data);
 519 }
 520
 521 uptr internal_waitpid(int pid, int *status, int options) {
 522   return internal_syscall(SYSCALL(wait4), pid, (uptr)status, options,
 523                           0 /* rusage */);
 524 }
 525
 526 uptr internal_getpid() {
 527   return internal_syscall(SYSCALL(getpid));
 528 }
 529
 530 uptr internal_getppid() {
 531   return internal_syscall(SYSCALL(getppid));
 532 }
 533
 534 uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {
 535 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 536   return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count);
 537 #else
 538   return internal_syscall(SYSCALL(getdents), fd, (uptr)dirp, count);
 539 #endif
 540 }
 541
 542 uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
 543   return internal_syscall(SYSCALL(lseek), fd, offset, whence);
 544 }
 545
 546 #if SANITIZER_LINUX
 547 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
 548   return internal_syscall(SYSCALL(prctl), option, arg2, arg3, arg4, arg5);
 549 }
 550 #endif
 551
 552 uptr internal_sigaltstack(const struct sigaltstack *ss,
 553                          struct sigaltstack *oss) {
 554   return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss);
 555 }
 556
 557 int internal_fork() {
 558 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 559   return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
 560 #else
 561   return internal_syscall(SYSCALL(fork));
 562 #endif
 563 }
 564
 565 #if SANITIZER_LINUX
 566 #define SA_RESTORER 0x04000000
 567 // Doesn't set sa_restorer, use with caution (see below).
 568 int internal_sigaction_norestorer(int signum, const void *act, void *oldact) {
 569   __sanitizer_kernel_sigaction_t k_act, k_oldact;
 570   internal_memset(&k_act, 0, sizeof(__sanitizer_kernel_sigaction_t));
 571   internal_memset(&k_oldact, 0, sizeof(__sanitizer_kernel_sigaction_t));
 572   const __sanitizer_sigaction *u_act = (const __sanitizer_sigaction *)act;
 573   __sanitizer_sigaction *u_oldact = (__sanitizer_sigaction *)oldact;
 574   if (u_act) {
 575     k_act.handler = u_act->handler;
 576     k_act.sigaction = u_act->sigaction;
 577     internal_memcpy(&k_act.sa_mask, &u_act->sa_mask,
 578                     sizeof(__sanitizer_kernel_sigset_t));
 579     // Without SA_RESTORER kernel ignores the calls (probably returns EINVAL).
 580     k_act.sa_flags = u_act->sa_flags | SA_RESTORER;
 581     // FIXME: most often sa_restorer is unset, however the kernel requires it
 582     // to point to a valid signal restorer that calls the rt_sigreturn syscall.
 583     // If sa_restorer passed to the kernel is NULL, the program may crash upon
 584     // signal delivery or fail to unwind the stack in the signal handler.
 585     // libc implementation of sigaction() passes its own restorer to
 586     // rt_sigaction, so we need to do the same (we'll need to reimplement the
 587     // restorers; for x86_64 the restorer address can be obtained from
 588     // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
 589     k_act.sa_restorer = u_act->sa_restorer;
 590   }
 591
 592   uptr result = internal_syscall(SYSCALL(rt_sigaction), (uptr)signum,
 593       (uptr)(u_act ? &k_act : nullptr),
 594       (uptr)(u_oldact ? &k_oldact : nullptr),
 595       (uptr)sizeof(__sanitizer_kernel_sigset_t));
 596
 597   if ((result == 0) && u_oldact) {
 598     u_oldact->handler = k_oldact.handler;
 599     u_oldact->sigaction = k_oldact.sigaction;
 600     internal_memcpy(&u_oldact->sa_mask, &k_oldact.sa_mask,
 601                     sizeof(__sanitizer_kernel_sigset_t));
 602     u_oldact->sa_flags = k_oldact.sa_flags;
 603     u_oldact->sa_restorer = k_oldact.sa_restorer;
 604   }
 605   return result;
 606 }
 607 #endif  // SANITIZER_LINUX
 608
 609 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
 610     __sanitizer_sigset_t *oldset) {
 611 #if SANITIZER_FREEBSD
 612   return internal_syscall(SYSCALL(sigprocmask), how, set, oldset);
 613 #else
 614   __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
 615   __sanitizer_kernel_sigset_t *k_oldset = (__sanitizer_kernel_sigset_t *)oldset;
 616   return internal_syscall(SYSCALL(rt_sigprocmask), (uptr)how,
 617                           (uptr)&k_set->sig[0], (uptr)&k_oldset->sig[0],
 618                           sizeof(__sanitizer_kernel_sigset_t));
 619 #endif
 620 }
 621
 622 void internal_sigfillset(__sanitizer_sigset_t *set) {
 623   internal_memset(set, 0xff, sizeof(*set));
 624 }
 625
 626 #if SANITIZER_LINUX
 627 void internal_sigdelset(__sanitizer_sigset_t *set, int signum) {
 628   signum -= 1;
 629   CHECK_GE(signum, 0);
 630   CHECK_LT(signum, sizeof(*set) * 8);
 631   __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
 632   const uptr idx = signum / (sizeof(k_set->sig[0]) * 8);
 633   const uptr bit = signum % (sizeof(k_set->sig[0]) * 8);
 634   k_set->sig[idx] &= ~(1 << bit);
 635 }
 636 #endif  // SANITIZER_LINUX
 637
 638 // ThreadLister implementation.
 639 ThreadLister::ThreadLister(int pid)
 640   : pid_(pid),
 641     descriptor_(-1),
 642     buffer_(4096),
 643     error_(true),
 644     entry_((struct linux_dirent *)buffer_.data()),
 645     bytes_read_(0) {
 646   char task_directory_path[80];
 647   internal_snprintf(task_directory_path, sizeof(task_directory_path),
 648                     "/proc/%d/task/", pid);
 649   uptr openrv = internal_open(task_directory_path, O_RDONLY | O_DIRECTORY);
 650   if (internal_iserror(openrv)) {
 651     error_ = true;
 652     Report("Can't open /proc/%d/task for reading.\n", pid);
 653   } else {
 654     error_ = false;
 655     descriptor_ = openrv;
 656   }
 657 }
 658
 659 int ThreadLister::GetNextTID() {
 660   int tid = -1;
 661   do {
 662     if (error_)
 663       return -1;
 664     if ((char *)entry_ >= &buffer_[bytes_read_] && !GetDirectoryEntries())
 665       return -1;
 666     if (entry_->d_ino != 0 && entry_->d_name[0] >= '0' &&
 667         entry_->d_name[0] <= '9') {
 668       // Found a valid tid.
 669       tid = (int)internal_atoll(entry_->d_name);
 670     }
 671     entry_ = (struct linux_dirent *)(((char *)entry_) + entry_->d_reclen);
 672   } while (tid < 0);
 673   return tid;
 674 }
 675
 676 void ThreadLister::Reset() {
 677   if (error_ || descriptor_ < 0)
 678     return;
 679   internal_lseek(descriptor_, 0, SEEK_SET);
 680 }
 681
 682 ThreadLister::~ThreadLister() {
 683   if (descriptor_ >= 0)
 684     internal_close(descriptor_);
 685 }
 686
 687 bool ThreadLister::error() { return error_; }
 688
 689 bool ThreadLister::GetDirectoryEntries() {
 690   CHECK_GE(descriptor_, 0);
 691   CHECK_NE(error_, true);
 692   bytes_read_ = internal_getdents(descriptor_,
 693                                   (struct linux_dirent *)buffer_.data(),
 694                                   buffer_.size());
 695   if (internal_iserror(bytes_read_)) {
 696     Report("Can't read directory entries from /proc/%d/task.\n", pid_);
 697     error_ = true;
 698     return false;
 699   } else if (bytes_read_ == 0) {
 700     return false;
 701   }
 702   entry_ = (struct linux_dirent *)buffer_.data();
 703   return true;
 704 }
 705
 706 uptr GetPageSize() {
 707 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__))
 708   return EXEC_PAGESIZE;
 709 #else
 710   return sysconf(_SC_PAGESIZE);  // EXEC_PAGESIZE may not be trustworthy.
 711 #endif
 712 }
 713
 714 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
 715 #if SANITIZER_FREEBSD
 716   const int Mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
 717   const char *default_module_name = "kern.proc.pathname";
 718   size_t Size = buf_len;
 719   bool IsErr = (sysctl(Mib, ARRAY_SIZE(Mib), buf, &Size, NULL, 0) != 0);
 720   int readlink_error = IsErr ? errno : 0;
 721   uptr module_name_len = Size;
 722 #else
 723   const char *default_module_name = "/proc/self/exe";
 724   uptr module_name_len = internal_readlink(
 725       default_module_name, buf, buf_len);
 726   int readlink_error;
 727   bool IsErr = internal_iserror(module_name_len, &readlink_error);
 728 #endif
 729   if (IsErr) {
 730     // We can't read binary name for some reason, assume it's unknown.
 731     Report("WARNING: reading executable name failed with errno %d, "
 732            "some stack frames may not be symbolized\n", readlink_error);
 733     module_name_len = internal_snprintf(buf, buf_len, "%s",
 734                                         default_module_name);
 735     CHECK_LT(module_name_len, buf_len);
 736   }
 737   return module_name_len;
 738 }
 739
 740 uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) {
 741 #if SANITIZER_LINUX
 742   char *tmpbuf;
 743   uptr tmpsize;
 744   uptr tmplen;
 745   if (ReadFileToBuffer("/proc/self/cmdline", &tmpbuf, &tmpsize, &tmplen,
 746                        1024 * 1024)) {
 747     internal_strncpy(buf, tmpbuf, buf_len);
 748     UnmapOrDie(tmpbuf, tmpsize);
 749     return internal_strlen(buf);
 750   }
 751 #endif
 752   return ReadBinaryName(buf, buf_len);
 753 }
 754
 755 // Match full names of the form /path/to/base_name{-,.}*
 756 bool LibraryNameIs(const char *full_name, const char *base_name) {
 757   const char *name = full_name;
 758   // Strip path.
 759   while (*name != '\0') name++;
 760   while (name > full_name && *name != '/') name--;
 761   if (*name == '/') name++;
 762   uptr base_name_length = internal_strlen(base_name);
 763   if (internal_strncmp(name, base_name, base_name_length)) return false;
 764   return (name[base_name_length] == '-' || name[base_name_length] == '.');
 765 }
 766
 767 #if !SANITIZER_ANDROID
 768 // Call cb for each region mapped by map.
 769 void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) {
 770   CHECK_NE(map, nullptr);
 771 #if !SANITIZER_FREEBSD
 772   typedef ElfW(Phdr) Elf_Phdr;
 773   typedef ElfW(Ehdr) Elf_Ehdr;
 774 #endif  // !SANITIZER_FREEBSD
 775   char *base = (char *)map->l_addr;
 776   Elf_Ehdr *ehdr = (Elf_Ehdr *)base;
 777   char *phdrs = base + ehdr->e_phoff;
 778   char *phdrs_end = phdrs + ehdr->e_phnum * ehdr->e_phentsize;
 779
 780   // Find the segment with the minimum base so we can "relocate" the p_vaddr
 781   // fields.  Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC
 782   // objects have a non-zero base.
 783   uptr preferred_base = (uptr)-1;
 784   for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) {
 785     Elf_Phdr *phdr = (Elf_Phdr *)iter;
 786     if (phdr->p_type == PT_LOAD && preferred_base > (uptr)phdr->p_vaddr)
 787       preferred_base = (uptr)phdr->p_vaddr;
 788   }
 789
 790   // Compute the delta from the real base to get a relocation delta.
 791   sptr delta = (uptr)base - preferred_base;
 792   // Now we can figure out what the loader really mapped.
 793   for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) {
 794     Elf_Phdr *phdr = (Elf_Phdr *)iter;
 795     if (phdr->p_type == PT_LOAD) {
 796       uptr seg_start = phdr->p_vaddr + delta;
 797       uptr seg_end = seg_start + phdr->p_memsz;
 798       // None of these values are aligned.  We consider the ragged edges of the
 799       // load command as defined, since they are mapped from the file.
 800       seg_start = RoundDownTo(seg_start, GetPageSizeCached());
 801       seg_end = RoundUpTo(seg_end, GetPageSizeCached());
 802       cb((void *)seg_start, seg_end - seg_start);
 803     }
 804   }
 805 }
 806 #endif
 807
 808 #if defined(__x86_64__) && SANITIZER_LINUX
 809 // We cannot use glibc's clone wrapper, because it messes with the child
 810 // task's TLS. It writes the PID and TID of the child task to its thread
 811 // descriptor, but in our case the child task shares the thread descriptor with
 812 // the parent (because we don't know how to allocate a new thread
 813 // descriptor to keep glibc happy). So the stock version of clone(), when
 814 // used with CLONE_VM, would end up corrupting the parent's thread descriptor.
 815 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
 816                     int *parent_tidptr, void *newtls, int *child_tidptr) {
 817   long long res;
 818   if (!fn || !child_stack)
 819     return -EINVAL;
 820   CHECK_EQ(0, (uptr)child_stack % 16);
 821   child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
 822   ((unsigned long long *)child_stack)[0] = (uptr)fn;
 823   ((unsigned long long *)child_stack)[1] = (uptr)arg;
 824   register void *r8 __asm__("r8") = newtls;
 825   register int *r10 __asm__("r10") = child_tidptr;
 826   __asm__ __volatile__(
 827                        /* %rax = syscall(%rax = SYSCALL(clone),
 828                         *                %rdi = flags,
 829                         *                %rsi = child_stack,
 830                         *                %rdx = parent_tidptr,
 831                         *                %r8  = new_tls,
 832                         *                %r10 = child_tidptr)
 833                         */
 834                        "syscall\n"
 835
 836                        /* if (%rax != 0)
 837                         *   return;
 838                         */
 839                        "testq  %%rax,%%rax\n"
 840                        "jnz    1f\n"
 841
 842                        /* In the child. Terminate unwind chain. */
 843                        // XXX: We should also terminate the CFI unwind chain
 844                        // here. Unfortunately clang 3.2 doesn't support the
 845                        // necessary CFI directives, so we skip that part.
 846                        "xorq   %%rbp,%%rbp\n"
 847
 848                        /* Call "fn(arg)". */
 849                        "popq   %%rax\n"
 850                        "popq   %%rdi\n"
 851                        "call   *%%rax\n"
 852
 853                        /* Call _exit(%rax). */
 854                        "movq   %%rax,%%rdi\n"
 855                        "movq   %2,%%rax\n"
 856                        "syscall\n"
 857
 858                        /* Return to parent. */
 859                      "1:\n"
 860                        : "=a" (res)
 861                        : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
 862                          "S"(child_stack),
 863                          "D"(flags),
 864                          "d"(parent_tidptr),
 865                          "r"(r8),
 866                          "r"(r10)
 867                        : "rsp", "memory", "r11", "rcx");
 868   return res;
 869 }
 870 #elif defined(__mips__)
 871 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
 872                     int *parent_tidptr, void *newtls, int *child_tidptr) {
 873   long long res;
 874   if (!fn || !child_stack)
 875     return -EINVAL;
 876   CHECK_EQ(0, (uptr)child_stack % 16);
 877   child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
 878   ((unsigned long long *)child_stack)[0] = (uptr)fn;
 879   ((unsigned long long *)child_stack)[1] = (uptr)arg;
 880   register void *a3 __asm__("$7") = newtls;
 881   register int *a4 __asm__("$8") = child_tidptr;
 882   // We don't have proper CFI directives here because it requires alot of code
 883   // for very marginal benefits.
 884   __asm__ __volatile__(
 885                        /* $v0 = syscall($v0 = __NR_clone,
 886                         * $a0 = flags,
 887                         * $a1 = child_stack,
 888                         * $a2 = parent_tidptr,
 889                         * $a3 = new_tls,
 890                         * $a4 = child_tidptr)
 891                         */
 892                        ".cprestore 16;\n"
 893                        "move $4,%1;\n"
 894                        "move $5,%2;\n"
 895                        "move $6,%3;\n"
 896                        "move $7,%4;\n"
 897                        /* Store the fifth argument on stack
 898                         * if we are using 32-bit abi.
 899                         */
 900 #if SANITIZER_WORDSIZE == 32
 901                        "lw %5,16($29);\n"
 902 #else
 903                        "move $8,%5;\n"
 904 #endif
 905                        "li $2,%6;\n"
 906                        "syscall;\n"
 907
 908                        /* if ($v0 != 0)
 909                         * return;
 910                         */
 911                        "bnez $2,1f;\n"
 912
 913                        /* Call "fn(arg)". */
 914                        "ld $25,0($29);\n"
 915                        "ld $4,8($29);\n"
 916                        "jal $25;\n"
 917
 918                        /* Call _exit($v0). */
 919                        "move $4,$2;\n"
 920                        "li $2,%7;\n"
 921                        "syscall;\n"
 922
 923                        /* Return to parent. */
 924                      "1:\n"
 925                        : "=r" (res)
 926                        : "r"(flags),
 927                          "r"(child_stack),
 928                          "r"(parent_tidptr),
 929                          "r"(a3),
 930                          "r"(a4),
 931                          "i"(__NR_clone),
 932                          "i"(__NR_exit)
 933                        : "memory", "$29" );
 934   return res;
 935 }
 936 #elif defined(__aarch64__)
 937 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
 938                     int *parent_tidptr, void *newtls, int *child_tidptr) {
 939   long long res;
 940   if (!fn || !child_stack)
 941     return -EINVAL;
 942   CHECK_EQ(0, (uptr)child_stack % 16);
 943   child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
 944   ((unsigned long long *)child_stack)[0] = (uptr)fn;
 945   ((unsigned long long *)child_stack)[1] = (uptr)arg;
 946
 947   register int (*__fn)(void *)  __asm__("x0") = fn;
 948   register void *__stack __asm__("x1") = child_stack;
 949   register int   __flags __asm__("x2") = flags;
 950   register void *__arg   __asm__("x3") = arg;
 951   register int  *__ptid  __asm__("x4") = parent_tidptr;
 952   register void *__tls   __asm__("x5") = newtls;
 953   register int  *__ctid  __asm__("x6") = child_tidptr;
 954
 955   __asm__ __volatile__(
 956                        "mov x0,x2\n" /* flags  */
 957                        "mov x2,x4\n" /* ptid  */
 958                        "mov x3,x5\n" /* tls  */
 959                        "mov x4,x6\n" /* ctid  */
 960                        "mov x8,%9\n" /* clone  */
 961
 962                        "svc 0x0\n"
 963
 964                        /* if (%r0 != 0)
 965                         *   return %r0;
 966                         */
 967                        "cmp x0, #0\n"
 968                        "bne 1f\n"
 969
 970                        /* In the child, now. Call "fn(arg)". */
 971                        "ldp x1, x0, [sp], #16\n"
 972                        "blr x1\n"
 973
 974                        /* Call _exit(%r0).  */
 975                        "mov x8, %10\n"
 976                        "svc 0x0\n"
 977                      "1:\n"
 978
 979                        : "=r" (res)
 980                        : "i"(-EINVAL),
 981                          "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg),
 982                          "r"(__ptid), "r"(__tls), "r"(__ctid),
 983                          "i"(__NR_clone), "i"(__NR_exit)
 984                        : "x30", "memory");
 985   return res;
 986 }
 987 #elif defined(__powerpc64__)
 988 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
 989                    int *parent_tidptr, void *newtls, int *child_tidptr) {
 990   long long res;
 991 /* Stack frame offsets.  */
 992 #if _CALL_ELF != 2
 993 #define FRAME_MIN_SIZE         112
 994 #define FRAME_TOC_SAVE         40
 995 #else
 996 #define FRAME_MIN_SIZE         32
 997 #define FRAME_TOC_SAVE         24
 998 #endif
 999   if (!fn || !child_stack)
1000     return -EINVAL;
1001   CHECK_EQ(0, (uptr)child_stack % 16);
1002   child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
1003   ((unsigned long long *)child_stack)[0] = (uptr)fn;
1004   ((unsigned long long *)child_stack)[1] = (uptr)arg;
1005
1006   register int (*__fn)(void *) __asm__("r3") = fn;
1007   register void *__cstack      __asm__("r4") = child_stack;
1008   register int __flags         __asm__("r5") = flags;
1009   register void * __arg        __asm__("r6") = arg;
1010   register int * __ptidptr     __asm__("r7") = parent_tidptr;
1011   register void * __newtls     __asm__("r8") = newtls;
1012   register int * __ctidptr     __asm__("r9") = child_tidptr;
1013
1014  __asm__ __volatile__(
1015            /* fn, arg, child_stack are saved acrVoss the syscall */
1016            "mr 28, %5\n\t"
1017            "mr 29, %6\n\t"
1018            "mr 27, %8\n\t"
1019
1020            /* syscall
1021              r3 == flags
1022              r4 == child_stack
1023              r5 == parent_tidptr
1024              r6 == newtls
1025              r7 == child_tidptr */
1026            "mr 3, %7\n\t"
1027            "mr 5, %9\n\t"
1028            "mr 6, %10\n\t"
1029            "mr 7, %11\n\t"
1030            "li 0, %3\n\t"
1031            "sc\n\t"
1032
1033            /* Test if syscall was successful */
1034            "cmpdi  cr1, 3, 0\n\t"
1035            "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
1036            "bne-   cr1, 1f\n\t"
1037
1038            /* Do the function call */
1039            "std   2, %13(1)\n\t"
1040 #if _CALL_ELF != 2
1041            "ld    0, 0(28)\n\t"
1042            "ld    2, 8(28)\n\t"
1043            "mtctr 0\n\t"
1044 #else
1045            "mr    12, 28\n\t"
1046            "mtctr 12\n\t"
1047 #endif
1048            "mr    3, 27\n\t"
1049            "bctrl\n\t"
1050            "ld    2, %13(1)\n\t"
1051
1052            /* Call _exit(r3) */
1053            "li 0, %4\n\t"
1054            "sc\n\t"
1055
1056            /* Return to parent */
1057            "1:\n\t"
1058            "mr %0, 3\n\t"
1059              : "=r" (res)
1060              : "0" (-1), "i" (EINVAL),
1061                "i" (__NR_clone), "i" (__NR_exit),
1062                "r" (__fn), "r" (__cstack), "r" (__flags),
1063                "r" (__arg), "r" (__ptidptr), "r" (__newtls),
1064                "r" (__ctidptr), "i" (FRAME_MIN_SIZE), "i" (FRAME_TOC_SAVE)
1065              : "cr0", "cr1", "memory", "ctr",
1066                "r0", "r29", "r27", "r28");
1067   return res;
1068 }
1069 #endif  // defined(__x86_64__) && SANITIZER_LINUX
1070
1071 #if SANITIZER_ANDROID
1072 #if __ANDROID_API__ < 21
1073 extern "C" __attribute__((weak)) int dl_iterate_phdr(
1074     int (*)(struct dl_phdr_info *, size_t, void *), void *);
1075 #endif
1076
1077 static int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
1078                                    void *data) {
1079   // Any name starting with "lib" indicates a bug in L where library base names
1080   // are returned instead of paths.
1081   if (info->dlpi_name && info->dlpi_name[0] == 'l' &&
1082       info->dlpi_name[1] == 'i' && info->dlpi_name[2] == 'b') {
1083     *(bool *)data = true;
1084     return 1;
1085   }
1086   return 0;
1087 }
1088
1089 static atomic_uint32_t android_api_level;
1090
1091 static AndroidApiLevel AndroidDetectApiLevel() {
1092   if (!&dl_iterate_phdr)
1093     return ANDROID_KITKAT; // K or lower
1094   bool base_name_seen = false;
1095   dl_iterate_phdr(dl_iterate_phdr_test_cb, &base_name_seen);
1096   if (base_name_seen)
1097     return ANDROID_LOLLIPOP_MR1; // L MR1
1098   return ANDROID_POST_LOLLIPOP;   // post-L
1099   // Plain L (API level 21) is completely broken wrt ASan and not very
1100   // interesting to detect.
1101 }
1102
1103 AndroidApiLevel AndroidGetApiLevel() {
1104   AndroidApiLevel level =
1105       (AndroidApiLevel)atomic_load(&android_api_level, memory_order_relaxed);
1106   if (level) return level;
1107   level = AndroidDetectApiLevel();
1108   atomic_store(&android_api_level, level, memory_order_relaxed);
1109   return level;
1110 }
1111
1112 #endif
1113
1114 bool IsDeadlySignal(int signum) {
1115   if (common_flags()->handle_abort && signum == SIGABRT)
1116     return true;
1117   if (common_flags()->handle_sigill && signum == SIGILL)
1118     return true;
1119   if (common_flags()->handle_sigfpe && signum == SIGFPE)
1120     return true;
1121   return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
1122 }
1123
1124 #ifndef SANITIZER_GO
1125 void *internal_start_thread(void(*func)(void *arg), void *arg) {
1126   // Start the thread with signals blocked, otherwise it can steal user signals.
1127   __sanitizer_sigset_t set, old;
1128   internal_sigfillset(&set);
1129 #if SANITIZER_LINUX && !SANITIZER_ANDROID
1130   // Glibc uses SIGSETXID signal during setuid call. If this signal is blocked
1131   // on any thread, setuid call hangs (see test/tsan/setuid.c).
1132   internal_sigdelset(&set, 33);
1133 #endif
1134   internal_sigprocmask(SIG_SETMASK, &set, &old);
1135   void *th;
1136   real_pthread_create(&th, nullptr, (void*(*)(void *arg))func, arg);
1137   internal_sigprocmask(SIG_SETMASK, &old, nullptr);
1138   return th;
1139 }
1140
1141 void internal_join_thread(void *th) {
1142   real_pthread_join(th, nullptr);
1143 }
1144 #else
1145 void *internal_start_thread(void (*func)(void *), void *arg) { return 0; }
1146
1147 void internal_join_thread(void *th) {}
1148 #endif
1149
1150 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
1151 #if defined(__arm__)
1152   ucontext_t *ucontext = (ucontext_t*)context;
1153   *pc = ucontext->uc_mcontext.arm_pc;
1154   *bp = ucontext->uc_mcontext.arm_fp;
1155   *sp = ucontext->uc_mcontext.arm_sp;
1156 #elif defined(__aarch64__)
1157   ucontext_t *ucontext = (ucontext_t*)context;
1158   *pc = ucontext->uc_mcontext.pc;
1159   *bp = ucontext->uc_mcontext.regs[29];
1160   *sp = ucontext->uc_mcontext.sp;
1161 #elif defined(__hppa__)
1162   ucontext_t *ucontext = (ucontext_t*)context;
1163   *pc = ucontext->uc_mcontext.sc_iaoq[0];
1164   /* GCC uses %r3 whenever a frame pointer is needed.  */
1165   *bp = ucontext->uc_mcontext.sc_gr[3];
1166   *sp = ucontext->uc_mcontext.sc_gr[30];
1167 #elif defined(__x86_64__)
1168 # if SANITIZER_FREEBSD
1169   ucontext_t *ucontext = (ucontext_t*)context;
1170   *pc = ucontext->uc_mcontext.mc_rip;
1171   *bp = ucontext->uc_mcontext.mc_rbp;
1172   *sp = ucontext->uc_mcontext.mc_rsp;
1173 # else
1174   ucontext_t *ucontext = (ucontext_t*)context;
1175   *pc = ucontext->uc_mcontext.gregs[REG_RIP];
1176   *bp = ucontext->uc_mcontext.gregs[REG_RBP];
1177   *sp = ucontext->uc_mcontext.gregs[REG_RSP];
1178 # endif
1179 #elif defined(__i386__)
1180 # if SANITIZER_FREEBSD
1181   ucontext_t *ucontext = (ucontext_t*)context;
1182   *pc = ucontext->uc_mcontext.mc_eip;
1183   *bp = ucontext->uc_mcontext.mc_ebp;
1184   *sp = ucontext->uc_mcontext.mc_esp;
1185 # else
1186   ucontext_t *ucontext = (ucontext_t*)context;
1187   *pc = ucontext->uc_mcontext.gregs[REG_EIP];
1188   *bp = ucontext->uc_mcontext.gregs[REG_EBP];
1189   *sp = ucontext->uc_mcontext.gregs[REG_ESP];
1190 # endif
1191 #elif defined(__powerpc__) || defined(__powerpc64__)
1192   ucontext_t *ucontext = (ucontext_t*)context;
1193   *pc = ucontext->uc_mcontext.regs->nip;
1194   *sp = ucontext->uc_mcontext.regs->gpr[PT_R1];
1195   // The powerpc{,64}-linux ABIs do not specify r31 as the frame
1196   // pointer, but GCC always uses r31 when we need a frame pointer.
1197   *bp = ucontext->uc_mcontext.regs->gpr[PT_R31];
1198 #elif defined(__sparc__)
1199   ucontext_t *ucontext = (ucontext_t*)context;
1200   uptr *stk_ptr;
1201 # if defined (__arch64__)
1202   *pc = ucontext->uc_mcontext.mc_gregs[MC_PC];
1203   *sp = ucontext->uc_mcontext.mc_gregs[MC_O6];
1204   stk_ptr = (uptr *) (*sp + 2047);
1205   *bp = stk_ptr[15];
1206 # else
1207   *pc = ucontext->uc_mcontext.gregs[REG_PC];
1208   *sp = ucontext->uc_mcontext.gregs[REG_O6];
1209   stk_ptr = (uptr *) *sp;
1210   *bp = stk_ptr[15];
1211 # endif
1212 #elif defined(__mips__)
1213   ucontext_t *ucontext = (ucontext_t*)context;
1214   *pc = ucontext->uc_mcontext.pc;
1215   *bp = ucontext->uc_mcontext.gregs[30];
1216   *sp = ucontext->uc_mcontext.gregs[29];
1217 #else
1218 # error "Unsupported arch"
1219 #endif
1220 }
1221
1222 void DisableReexec() {
1223   // No need to re-exec on Linux.
1224 }
1225
1226 void MaybeReexec() {
1227   // No need to re-exec on Linux.
1228 }
1229
1230 } // namespace __sanitizer
1231
1232 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX